diff --git a/src/applications/repository/query/PhabricatorRepositoryQuery.php b/src/applications/repository/query/PhabricatorRepositoryQuery.php
index 9a056b202a..7595cd0c8e 100644
--- a/src/applications/repository/query/PhabricatorRepositoryQuery.php
+++ b/src/applications/repository/query/PhabricatorRepositoryQuery.php
@@ -1,551 +1,544 @@
 <?php
 
 final class PhabricatorRepositoryQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $callsigns;
   private $types;
   private $uuids;
   private $nameContains;
   private $remoteURIs;
   private $datasourceQuery;
 
   private $numericIdentifiers;
   private $callsignIdentifiers;
   private $phidIdentifiers;
 
   private $identifierMap;
 
   const STATUS_OPEN = 'status-open';
   const STATUS_CLOSED = 'status-closed';
   const STATUS_ALL = 'status-all';
   private $status = self::STATUS_ALL;
 
   const HOSTED_PHABRICATOR = 'hosted-phab';
   const HOSTED_REMOTE = 'hosted-remote';
   const HOSTED_ALL = 'hosted-all';
   private $hosted = self::HOSTED_ALL;
 
   private $needMostRecentCommits;
   private $needCommitCounts;
   private $needProjectPHIDs;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withCallsigns(array $callsigns) {
     $this->callsigns = $callsigns;
     return $this;
   }
 
   public function withIdentifiers(array $identifiers) {
     $ids = array(); $callsigns = array(); $phids = array();
     foreach ($identifiers as $identifier) {
       if (ctype_digit($identifier)) {
         $ids[$identifier] = $identifier;
       } else {
         $repository_type = PhabricatorRepositoryRepositoryPHIDType::TYPECONST;
         if (phid_get_type($identifier) === $repository_type) {
           $phids[$identifier] = $identifier;
         } else {
           $callsigns[$identifier] = $identifier;
         }
       }
     }
 
     $this->numericIdentifiers = $ids;
     $this->callsignIdentifiers = $callsigns;
     $this->phidIdentifiers = $phids;
     return $this;
   }
 
   public function withStatus($status) {
     $this->status = $status;
     return $this;
   }
 
   public function withHosted($hosted) {
     $this->hosted = $hosted;
     return $this;
   }
 
   public function withTypes(array $types) {
     $this->types = $types;
     return $this;
   }
 
   public function withUUIDs(array $uuids) {
     $this->uuids = $uuids;
     return $this;
   }
 
   public function withNameContains($contains) {
     $this->nameContains = $contains;
     return $this;
   }
 
   public function withRemoteURIs(array $uris) {
     $this->remoteURIs = $uris;
     return $this;
   }
 
   public function withDatasourceQuery($query) {
     $this->datasourceQuery = $query;
     return $this;
   }
 
   public function needCommitCounts($need_counts) {
     $this->needCommitCounts = $need_counts;
     return $this;
   }
 
   public function needMostRecentCommits($need_commits) {
     $this->needMostRecentCommits = $need_commits;
     return $this;
   }
 
   public function needProjectPHIDs($need_phids) {
     $this->needProjectPHIDs = $need_phids;
     return $this;
   }
 
   public function getBuiltinOrders() {
     return array(
       'committed' => array(
         'vector' => array('committed', 'id'),
         'name' => pht('Most Recent Commit'),
       ),
       'name' => array(
         'vector' => array('name', 'id'),
         'name' => pht('Name'),
       ),
       'callsign' => array(
         'vector' => array('callsign'),
         'name' => pht('Callsign'),
       ),
       'size' => array(
         'vector' => array('size', 'id'),
         'name' => pht('Size'),
       ),
     ) + parent::getBuiltinOrders();
   }
 
   public function getIdentifierMap() {
     if ($this->identifierMap === null) {
       throw new PhutilInvalidStateException('execute');
     }
     return $this->identifierMap;
   }
 
   protected function willExecute() {
     $this->identifierMap = array();
   }
 
-  protected function loadPage() {
-    $table = new PhabricatorRepository();
-    $conn_r = $table->establishConnection('r');
-
-    $data = queryfx_all(
-      $conn_r,
-      '%Q FROM %T r %Q %Q %Q %Q %Q %Q',
-      $this->buildSelectClause($conn_r),
-      $table->getTableName(),
-      $this->buildJoinClause($conn_r),
-      $this->buildWhereClause($conn_r),
-      $this->buildGroupClause($conn_r),
-      $this->buildHavingClause($conn_r),
-      $this->buildOrderClause($conn_r),
-      $this->buildLimitClause($conn_r));
+  public function newResultObject() {
+    return new PhabricatorRepository();
+  }
 
+  protected function loadPage() {
+    $table = $this->newResultObject();
+    $data = $this->loadStandardPageRows($table);
     $repositories = $table->loadAllFromArray($data);
 
     if ($this->needCommitCounts) {
       $sizes = ipull($data, 'size', 'id');
       foreach ($repositories as $id => $repository) {
         $repository->attachCommitCount(nonempty($sizes[$id], 0));
       }
     }
 
     if ($this->needMostRecentCommits) {
       $commit_ids = ipull($data, 'lastCommitID', 'id');
       $commit_ids = array_filter($commit_ids);
       if ($commit_ids) {
         $commits = id(new DiffusionCommitQuery())
           ->setViewer($this->getViewer())
           ->withIDs($commit_ids)
           ->execute();
       } else {
         $commits = array();
       }
       foreach ($repositories as $id => $repository) {
         $commit = null;
         if (idx($commit_ids, $id)) {
           $commit = idx($commits, $commit_ids[$id]);
         }
         $repository->attachMostRecentCommit($commit);
       }
     }
 
     return $repositories;
   }
 
   protected function willFilterPage(array $repositories) {
     assert_instances_of($repositories, 'PhabricatorRepository');
 
     // TODO: Denormalize repository status into the PhabricatorRepository
     // table so we can do this filtering in the database.
     foreach ($repositories as $key => $repo) {
       $status = $this->status;
       switch ($status) {
         case self::STATUS_OPEN:
           if (!$repo->isTracked()) {
             unset($repositories[$key]);
           }
           break;
         case self::STATUS_CLOSED:
           if ($repo->isTracked()) {
             unset($repositories[$key]);
           }
           break;
         case self::STATUS_ALL:
           break;
         default:
           throw new Exception("Unknown status '{$status}'!");
       }
 
       // TODO: This should also be denormalized.
       $hosted = $this->hosted;
       switch ($hosted) {
         case self::HOSTED_PHABRICATOR:
           if (!$repo->isHosted()) {
             unset($repositories[$key]);
           }
           break;
         case self::HOSTED_REMOTE:
           if ($repo->isHosted()) {
             unset($repositories[$key]);
           }
           break;
         case self::HOSTED_ALL:
           break;
         default:
           throw new Exception(pht("Unknown hosted failed '%s'!", $hosted));
       }
     }
 
     // TODO: Denormalize this, too.
     if ($this->remoteURIs) {
       $try_uris = $this->getNormalizedPaths();
       $try_uris = array_fuse($try_uris);
       foreach ($repositories as $key => $repository) {
         if (!isset($try_uris[$repository->getNormalizedPath()])) {
           unset($repositories[$key]);
         }
       }
     }
 
     // Build the identifierMap
     if ($this->numericIdentifiers) {
       foreach ($this->numericIdentifiers as $id) {
         if (isset($repositories[$id])) {
           $this->identifierMap[$id] = $repositories[$id];
         }
       }
     }
 
     if ($this->callsignIdentifiers) {
       $repository_callsigns = mpull($repositories, null, 'getCallsign');
 
       foreach ($this->callsignIdentifiers as $callsign) {
         if (isset($repository_callsigns[$callsign])) {
           $this->identifierMap[$callsign] = $repository_callsigns[$callsign];
         }
       }
     }
 
     if ($this->phidIdentifiers) {
       $repository_phids = mpull($repositories, null, 'getPHID');
 
       foreach ($this->phidIdentifiers as $phid) {
         if (isset($repository_phids[$phid])) {
           $this->identifierMap[$phid] = $repository_phids[$phid];
         }
       }
     }
 
     return $repositories;
   }
 
   protected function didFilterPage(array $repositories) {
     if ($this->needProjectPHIDs) {
       $type_project = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
 
       $edge_query = id(new PhabricatorEdgeQuery())
         ->withSourcePHIDs(mpull($repositories, 'getPHID'))
         ->withEdgeTypes(array($type_project));
       $edge_query->execute();
 
       foreach ($repositories as $repository) {
         $project_phids = $edge_query->getDestinationPHIDs(
           array(
             $repository->getPHID(),
           ));
         $repository->attachProjectPHIDs($project_phids);
       }
     }
 
     return $repositories;
   }
 
   protected function getPrimaryTableAlias() {
     return 'r';
   }
 
   public function getOrderableColumns() {
     return parent::getOrderableColumns() + array(
       'committed' => array(
         'table' => 's',
         'column' => 'epoch',
         'type' => 'int',
         'null' => 'tail',
       ),
       'callsign' => array(
         'table' => 'r',
         'column' => 'callsign',
         'type' => 'string',
         'unique' => true,
         'reverse' => true,
       ),
       'name' => array(
         'table' => 'r',
         'column' => 'name',
         'type' => 'string',
         'reverse' => true,
       ),
       'size' => array(
         'table' => 's',
         'column' => 'size',
         'type' => 'int',
         'null' => 'tail',
       ),
     );
   }
 
   protected function willExecuteCursorQuery(
     PhabricatorCursorPagedPolicyAwareQuery $query) {
     $vector = $this->getOrderVector();
 
     if ($vector->containsKey('committed')) {
       $query->needMostRecentCommits(true);
     }
 
     if ($vector->containsKey('size')) {
       $query->needCommitCounts(true);
     }
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $repository = $this->loadCursorObject($cursor);
 
     $map = array(
       'id' => $repository->getID(),
       'callsign' => $repository->getCallsign(),
       'name' => $repository->getName(),
     );
 
     foreach ($keys as $key) {
       switch ($key) {
         case 'committed':
           $commit = $repository->getMostRecentCommit();
           if ($commit) {
             $map[$key] = $commit->getEpoch();
           } else {
             $map[$key] = null;
           }
           break;
         case 'size':
           $count = $repository->getCommitCount();
           if ($count) {
             $map[$key] = $count;
           } else {
             $map[$key] = null;
           }
           break;
       }
     }
 
     return $map;
   }
 
-  protected function buildSelectClause(AphrontDatabaseConnection $conn) {
-    $parts = $this->buildSelectClauseParts($conn);
+  protected function buildSelectClauseParts(AphrontDatabaseConnection $conn) {
+    $parts = parent::buildSelectClauseParts($conn);
+
     if ($this->shouldJoinSummaryTable()) {
       $parts[] = 's.*';
     }
-    return $this->formatSelectClause($parts);
+
+    return $parts;
   }
 
-  protected function buildJoinClause(AphrontDatabaseConnection $conn_r) {
-    $joins = $this->buildJoinClauseParts($conn_r);
+  protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
+    $joins = parent::buildJoinClauseParts($conn);
 
     if ($this->shouldJoinSummaryTable()) {
       $joins[] = qsprintf(
-        $conn_r,
+        $conn,
         'LEFT JOIN %T s ON r.id = s.repositoryID',
         PhabricatorRepository::TABLE_SUMMARY);
     }
 
-    return $this->formatJoinClause($joins);
+    return $joins;
   }
 
   private function shouldJoinSummaryTable() {
     if ($this->needCommitCounts) {
       return true;
     }
 
     if ($this->needMostRecentCommits) {
       return true;
     }
 
     $vector = $this->getOrderVector();
     if ($vector->containsKey('committed')) {
       return true;
     }
 
     if ($vector->containsKey('size')) {
       return true;
     }
 
     return false;
   }
 
-  protected function buildWhereClauseParts(AphrontDatabaseConnection $conn_r) {
-    $where = parent::buildWhereClauseParts($conn_r);
+  protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
+    $where = parent::buildWhereClauseParts($conn);
 
-    if ($this->ids) {
+    if ($this->ids !== null) {
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'r.id IN (%Ld)',
         $this->ids);
     }
 
-    if ($this->phids) {
+    if ($this->phids !== null) {
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'r.phid IN (%Ls)',
         $this->phids);
     }
 
-    if ($this->callsigns) {
+    if ($this->callsigns !== null) {
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'r.callsign IN (%Ls)',
         $this->callsigns);
     }
 
     if ($this->numericIdentifiers ||
       $this->callsignIdentifiers ||
       $this->phidIdentifiers) {
       $identifier_clause = array();
 
       if ($this->numericIdentifiers) {
         $identifier_clause[] = qsprintf(
-          $conn_r,
+          $conn,
           'r.id IN (%Ld)',
           $this->numericIdentifiers);
       }
 
       if ($this->callsignIdentifiers) {
         $identifier_clause[] = qsprintf(
-          $conn_r,
+          $conn,
           'r.callsign IN (%Ls)',
           $this->callsignIdentifiers);
       }
 
       if ($this->phidIdentifiers) {
         $identifier_clause[] = qsprintf(
-          $conn_r,
+          $conn,
           'r.phid IN (%Ls)',
           $this->phidIdentifiers);
       }
 
       $where = array('('.implode(' OR ', $identifier_clause).')');
     }
 
     if ($this->types) {
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'r.versionControlSystem IN (%Ls)',
         $this->types);
     }
 
     if ($this->uuids) {
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'r.uuid IN (%Ls)',
         $this->uuids);
     }
 
     if (strlen($this->nameContains)) {
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'name LIKE %~',
         $this->nameContains);
     }
 
     if (strlen($this->datasourceQuery)) {
       // This handles having "rP" match callsigns starting with "P...".
       $query = trim($this->datasourceQuery);
       if (preg_match('/^r/', $query)) {
         $callsign = substr($query, 1);
       } else {
         $callsign = $query;
       }
       $where[] = qsprintf(
-        $conn_r,
+        $conn,
         'r.name LIKE %> OR r.callsign LIKE %>',
         $query,
         $callsign);
     }
 
     return $where;
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorDiffusionApplication';
   }
 
   private function getNormalizedPaths() {
     $normalized_uris = array();
 
     // Since we don't know which type of repository this URI is in the general
     // case, just generate all the normalizations. We could refine this in some
     // cases: if the query specifies VCS types, or the URI is a git-style URI
     // or an `svn+ssh` URI, we could deduce how to normalize it. However, this
     // would be more complicated and it's not clear if it matters in practice.
 
     foreach ($this->remoteURIs as $uri) {
       $normalized_uris[] = new PhabricatorRepositoryURINormalizer(
         PhabricatorRepositoryURINormalizer::TYPE_GIT,
         $uri);
       $normalized_uris[] = new PhabricatorRepositoryURINormalizer(
         PhabricatorRepositoryURINormalizer::TYPE_SVN,
         $uri);
       $normalized_uris[] = new PhabricatorRepositoryURINormalizer(
         PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
         $uri);
     }
 
     return array_unique(mpull($normalized_uris, 'getNormalizedPath'));
   }
 
 }
diff --git a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
index 21c7fe38ab..e4c1eb14c6 100644
--- a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
+++ b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
@@ -1,282 +1,231 @@
 <?php
 
 final class PhabricatorRepositorySearchEngine
   extends PhabricatorApplicationSearchEngine {
 
   public function getResultTypeDescription() {
     return pht('Repositories');
   }
 
   public function getApplicationClassName() {
     return 'PhabricatorDiffusionApplication';
   }
 
-  public function buildSavedQueryFromRequest(AphrontRequest $request) {
-    $saved = new PhabricatorSavedQuery();
-
-    $saved->setParameter('callsigns', $request->getStrList('callsigns'));
-    $saved->setParameter('status', $request->getStr('status'));
-    $saved->setParameter('order', $request->getStr('order'));
-    $saved->setParameter('hosted', $request->getStr('hosted'));
-    $saved->setParameter('types', $request->getArr('types'));
-    $saved->setParameter('name', $request->getStr('name'));
-
-    $saved->setParameter(
-      'projects',
-      $this->readProjectsFromRequest($request, 'projects'));
-
-    return $saved;
-  }
-
-  public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
-    $query = id(new PhabricatorRepositoryQuery())
+  public function newQuery() {
+    return id(new PhabricatorRepositoryQuery())
       ->needProjectPHIDs(true)
       ->needCommitCounts(true)
       ->needMostRecentCommits(true);
+  }
 
-    $callsigns = $saved->getParameter('callsigns');
-    if ($callsigns) {
-      $query->withCallsigns($callsigns);
-    }
-
-    $status = $saved->getParameter('status');
-    $status = idx($this->getStatusValues(), $status);
-    if ($status) {
-      $query->withStatus($status);
-    }
+  protected function buildCustomSearchFields() {
+    return array(
+      id(new PhabricatorSearchStringListField())
+        ->setLabel(pht('Callsigns'))
+        ->setKey('callsigns'),
+      id(new PhabricatorSearchTextField())
+        ->setLabel(pht('Name Contains'))
+        ->setKey('name'),
+      id(new PhabricatorSearchSelectField())
+        ->setLabel(pht('Status'))
+        ->setKey('status')
+        ->setOptions($this->getStatusOptions()),
+      id(new PhabricatorSearchSelectField())
+        ->setLabel(pht('Hosted'))
+        ->setKey('hosted')
+        ->setOptions($this->getHostedOptions()),
+      id(new PhabricatorSearchCheckboxesField())
+        ->setLabel(pht('Types'))
+        ->setKey('types')
+        ->setOptions(PhabricatorRepositoryType::getAllRepositoryTypes()),
+    );
+  }
 
-    $this->setQueryOrder($query, $saved);
+  public function buildQueryFromParameters(array $map) {
+    $query = $this->newQuery();
 
-    $hosted = $saved->getParameter('hosted');
-    $hosted = idx($this->getHostedValues(), $hosted);
-    if ($hosted) {
-      $query->withHosted($hosted);
+    if ($map['callsigns']) {
+      $query->withCallsigns($map['callsigns']);
     }
 
-    $types = $saved->getParameter('types');
-    if ($types) {
-      $query->withTypes($types);
+    if ($map['status']) {
+      $status = idx($this->getStatusValues(), $map['status']);
+      if ($status) {
+        $query->withStatus($status);
+      }
     }
 
-    $name = $saved->getParameter('name');
-    if (strlen($name)) {
-      $query->withNameContains($name);
+    if ($map['hosted']) {
+      $hosted = idx($this->getHostedValues(), $map['hosted']);
+      if ($hosted) {
+        $query->withHosted($hosted);
+      }
     }
 
-    $adjusted = clone $saved;
-    $adjusted->setParameter('projects', $this->readProjectTokens($saved));
-    $this->setQueryProjects($query, $adjusted);
-
-    return $query;
-  }
+    if ($map['types']) {
+      $query->withTypes($map['types']);
+    }
 
-  public function buildSearchForm(
-    AphrontFormView $form,
-    PhabricatorSavedQuery $saved_query) {
-
-    $callsigns = $saved_query->getParameter('callsigns', array());
-    $types = $saved_query->getParameter('types', array());
-    $types = array_fuse($types);
-    $name = $saved_query->getParameter('name');
-    $projects = $this->readProjectTokens($saved_query);
-
-    $form
-      ->appendChild(
-        id(new AphrontFormTextControl())
-          ->setName('callsigns')
-          ->setLabel(pht('Callsigns'))
-          ->setValue(implode(', ', $callsigns)))
-      ->appendChild(
-        id(new AphrontFormTextControl())
-          ->setName('name')
-          ->setLabel(pht('Name Contains'))
-          ->setValue($name))
-      ->appendControl(
-        id(new AphrontFormTokenizerControl())
-          ->setDatasource(new PhabricatorProjectLogicalDatasource())
-          ->setName('projects')
-          ->setLabel(pht('Projects'))
-          ->setValue($projects))
-      ->appendChild(
-        id(new AphrontFormSelectControl())
-          ->setName('status')
-          ->setLabel(pht('Status'))
-          ->setValue($saved_query->getParameter('status'))
-          ->setOptions($this->getStatusOptions()))
-      ->appendChild(
-        id(new AphrontFormSelectControl())
-          ->setName('hosted')
-          ->setLabel(pht('Hosted'))
-          ->setValue($saved_query->getParameter('hosted'))
-          ->setOptions($this->getHostedOptions()));
-
-    $type_control = id(new AphrontFormCheckboxControl())
-      ->setLabel(pht('Types'));
-
-    $all_types = PhabricatorRepositoryType::getAllRepositoryTypes();
-    foreach ($all_types as $key => $name) {
-      $type_control->addCheckbox(
-        'types[]',
-        $key,
-        $name,
-        isset($types[$key]));
+    if (strlen($map['name'])) {
+      $query->withNameContains($map['name']);
     }
-    $form->appendChild($type_control);
 
-    $this->appendOrderFieldsToForm(
-      $form,
-      $saved_query,
-      new PhabricatorRepositoryQuery());
+    return $query;
   }
 
   protected function getURI($path) {
     return '/diffusion/'.$path;
   }
 
   protected function getBuiltinQueryNames() {
     $names = array(
       'active' => pht('Active Repositories'),
       'all' => pht('All Repositories'),
     );
 
     return $names;
   }
 
   public function buildSavedQueryFromBuiltin($query_key) {
 
     $query = $this->newSavedQuery();
     $query->setQueryKey($query_key);
 
     switch ($query_key) {
       case 'active':
         return $query->setParameter('status', 'open');
       case 'all':
         return $query;
     }
 
     return parent::buildSavedQueryFromBuiltin($query_key);
   }
 
   private function getStatusOptions() {
     return array(
       '' => pht('Active and Inactive Repositories'),
       'open' => pht('Active Repositories'),
       'closed' => pht('Inactive Repositories'),
     );
   }
 
   private function getStatusValues() {
     return array(
       '' => PhabricatorRepositoryQuery::STATUS_ALL,
       'open' => PhabricatorRepositoryQuery::STATUS_OPEN,
       'closed' => PhabricatorRepositoryQuery::STATUS_CLOSED,
     );
   }
 
   private function getHostedOptions() {
     return array(
       '' => pht('Hosted and Remote Repositories'),
       'phabricator' => pht('Hosted Repositories'),
       'remote' => pht('Remote Repositories'),
     );
   }
 
   private function getHostedValues() {
     return array(
       '' => PhabricatorRepositoryQuery::HOSTED_ALL,
       'phabricator' => PhabricatorRepositoryQuery::HOSTED_PHABRICATOR,
       'remote' => PhabricatorRepositoryQuery::HOSTED_REMOTE,
     );
   }
 
   protected function getRequiredHandlePHIDsForResultList(
     array $repositories,
     PhabricatorSavedQuery $query) {
     return array_mergev(mpull($repositories, 'getProjectPHIDs'));
   }
 
   protected function renderResultList(
     array $repositories,
     PhabricatorSavedQuery $query,
     array $handles) {
     assert_instances_of($repositories, 'PhabricatorRepository');
 
     $viewer = $this->requireViewer();
 
     $list = new PHUIObjectItemListView();
     foreach ($repositories as $repository) {
       $id = $repository->getID();
 
       $item = id(new PHUIObjectItemView())
         ->setUser($viewer)
         ->setHeader($repository->getName())
         ->setObjectName('r'.$repository->getCallsign())
         ->setHref($this->getApplicationURI($repository->getCallsign().'/'));
 
       $commit = $repository->getMostRecentCommit();
       if ($commit) {
         $commit_link = DiffusionView::linkCommit(
             $repository,
             $commit->getCommitIdentifier(),
             $commit->getSummary());
         $item->setSubhead($commit_link);
         $item->setEpoch($commit->getEpoch());
       }
 
       $item->addIcon(
         'none',
         PhabricatorRepositoryType::getNameForRepositoryType(
           $repository->getVersionControlSystem()));
 
       $size = $repository->getCommitCount();
       if ($size) {
         $history_uri = DiffusionRequest::generateDiffusionURI(
           array(
             'callsign' => $repository->getCallsign(),
             'action' => 'history',
           ));
 
         $item->addAttribute(
           phutil_tag(
             'a',
             array(
               'href' => $history_uri,
             ),
             pht('%s Commit(s)', new PhutilNumber($size))));
       } else {
         $item->addAttribute(pht('No Commits'));
       }
 
       $project_handles = array_select_keys(
         $handles,
         $repository->getProjectPHIDs());
       if ($project_handles) {
         $item->addAttribute(
           id(new PHUIHandleTagListView())
             ->setSlim(true)
             ->setHandles($project_handles));
       }
 
       if (!$repository->isTracked()) {
         $item->setDisabled(true);
         $item->addIcon('disable-grey', pht('Inactive'));
       }
 
       $list->addItem($item);
     }
 
     return $list;
   }
 
-  private function readProjectTokens(PhabricatorSavedQuery $saved) {
-    $projects = $saved->getParameter('projects', array());
+  protected function willUseSavedQuery(PhabricatorSavedQuery $saved) {
+    $project_phids = $saved->getParameter('projectPHIDs', array());
+
+    $old = $saved->getParameter('projects', array());
+    foreach ($old as $phid) {
+      $project_phids[] = $phid;
+    }
 
     $any = $saved->getParameter('anyProjectPHIDs', array());
     foreach ($any as $project) {
-      $projects[] = 'any('.$project.')';
+      $project_phids[] = 'any('.$project.')';
     }
 
-    return $projects;
+    $saved->setParameter('projectPHIDs', $project_phids);
   }
 
 }
diff --git a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
index e1e094a8ff..419447497c 100644
--- a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
+++ b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
@@ -1,1231 +1,1218 @@
 <?php
 
 /**
  * Represents an abstract search engine for an application. It supports
  * creating and storing saved queries.
  *
  * @task construct  Constructing Engines
  * @task app        Applications
  * @task builtin    Builtin Queries
  * @task uri        Query URIs
  * @task dates      Date Filters
  * @task order      Result Ordering
  * @task read       Reading Utilities
  * @task exec       Paging and Executing Queries
  * @task render     Rendering Results
  */
 abstract class PhabricatorApplicationSearchEngine extends Phobject {
 
   private $application;
   private $viewer;
   private $errors = array();
   private $customFields = false;
   private $request;
   private $context;
 
   const CONTEXT_LIST  = 'list';
   const CONTEXT_PANEL = 'panel';
 
   public function newResultObject() {
     // We may be able to get this automatically if newQuery() is implemented.
     $query = $this->newQuery();
     if ($query) {
       $object = $query->newResultObject();
       if ($object) {
         return $object;
       }
     }
 
     return null;
   }
 
   public function newQuery() {
     return null;
   }
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   protected function requireViewer() {
     if (!$this->viewer) {
       throw new PhutilInvalidStateException('setViewer');
     }
     return $this->viewer;
   }
 
   public function setContext($context) {
     $this->context = $context;
     return $this;
   }
 
   public function isPanelContext() {
     return ($this->context == self::CONTEXT_PANEL);
   }
 
   public function canUseInPanelContext() {
     return true;
   }
 
   public function saveQuery(PhabricatorSavedQuery $query) {
     $query->setEngineClassName(get_class($this));
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
     try {
       $query->save();
     } catch (AphrontDuplicateKeyQueryException $ex) {
       // Ignore, this is just a repeated search.
     }
     unset($unguarded);
   }
 
   /**
    * Create a saved query object from the request.
    *
    * @param AphrontRequest The search request.
    * @return PhabricatorSavedQuery
    */
   public function buildSavedQueryFromRequest(AphrontRequest $request) {
     $fields = $this->buildSearchFields();
     $viewer = $this->requireViewer();
 
     $saved = new PhabricatorSavedQuery();
     foreach ($fields as $field) {
       $field->setViewer($viewer);
 
       $value = $field->readValueFromRequest($request);
       $saved->setParameter($field->getKey(), $value);
     }
 
     return $saved;
   }
 
   /**
    * Executes the saved query.
    *
    * @param PhabricatorSavedQuery The saved query to operate on.
    * @return The result of the query.
    */
   public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
+    $saved = clone $saved;
+    $this->willUseSavedQuery($saved);
+
     $fields = $this->buildSearchFields();
     $viewer = $this->requireViewer();
 
     $map = array();
     foreach ($fields as $field) {
       $field->setViewer($viewer);
       $field->readValueFromSavedQuery($saved);
       $value = $field->getValueForQuery($field->getValue());
       $map[$field->getKey()] = $value;
     }
 
     $query = $this->buildQueryFromParameters($map);
 
     $object = $this->newResultObject();
     if (!$object) {
       return $query;
     }
 
     if ($object instanceof PhabricatorSubscribableInterface) {
       if (!empty($map['subscriberPHIDs'])) {
         $query->withEdgeLogicPHIDs(
           PhabricatorObjectHasSubscriberEdgeType::EDGECONST,
           PhabricatorQueryConstraint::OPERATOR_OR,
           $map['subscriberPHIDs']);
       }
     }
 
     if ($object instanceof PhabricatorProjectInterface) {
       if (!empty($map['projectPHIDs'])) {
         $query->withEdgeLogicConstraints(
           PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
           $map['projectPHIDs']);
       }
     }
 
     if ($object instanceof PhabricatorSpacesInterface) {
       if (!empty($map['spacePHIDs'])) {
         $query->withSpacePHIDs($map['spacePHIDs']);
       }
     }
 
     if ($object instanceof PhabricatorCustomFieldInterface) {
       $this->applyCustomFieldsToQuery($query, $saved);
     }
 
-    $this->setQueryOrder($query, $saved);
+    $order = $saved->getParameter('order');
+    $builtin = $query->getBuiltinOrders();
+    if (strlen($order) && isset($builtin[$order])) {
+      $query->setOrder($order);
+    } else {
+      // If the order is invalid or not available, we choose the first
+      // builtin order. This isn't always the default order for the query,
+      // but is the first value in the "Order" dropdown, and makes the query
+      // behavior more consistent with the UI. In queries where the two
+      // orders differ, this order is the preferred order for humans.
+      $query->setOrder(head_key($builtin));
+    }
 
     return $query;
   }
 
+  /**
+   * Hook for subclasses to adjust saved queries prior to use.
+   *
+   * If an application changes how queries are saved, it can implement this
+   * hook to keep old queries working the way users expect, by reading,
+   * adjusting, and overwriting parameters.
+   *
+   * @param PhabricatorSavedQuery Saved query which will be executed.
+   * @return void
+   */
+  protected function willUseSavedQuery(PhabricatorSavedQuery $saved) {
+    return;
+  }
+
   protected function buildQueryFromParameters(array $parameters) {
     throw new PhutilMethodNotImplementedException();
   }
 
   /**
    * Builds the search form using the request.
    *
    * @param AphrontFormView       Form to populate.
    * @param PhabricatorSavedQuery The query from which to build the form.
    * @return void
    */
   public function buildSearchForm(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved) {
 
+    $saved = clone $saved;
+    $this->willUseSavedQuery($saved);
+
     $fields = $this->buildSearchFields();
     $viewer = $this->requireViewer();
 
     foreach ($fields as $field) {
       $field->setViewer($viewer);
       $field->readValueFromSavedQuery($saved);
     }
 
     foreach ($fields as $field) {
       foreach ($field->getErrors() as $error) {
         $this->addError(last($error));
       }
     }
 
     foreach ($fields as $field) {
       $field->appendToForm($form);
     }
   }
 
   protected function buildSearchFields() {
     $fields = array();
 
     foreach ($this->buildCustomSearchFields() as $field) {
       $fields[] = $field;
     }
 
     $object = $this->newResultObject();
     if ($object) {
       if ($object instanceof PhabricatorSubscribableInterface) {
         $fields[] = id(new PhabricatorSearchSubscribersField())
           ->setLabel(pht('Subscribers'))
           ->setKey('subscriberPHIDs')
           ->setAliases(array('subscriber', 'subscribers'));
       }
 
       if ($object instanceof PhabricatorProjectInterface) {
         $fields[] = id(new PhabricatorSearchProjectsField())
           ->setKey('projectPHIDs')
           ->setAliases(array('project', 'projects'))
           ->setLabel(pht('Projects'));
       }
 
       if ($object instanceof PhabricatorSpacesInterface) {
         if (PhabricatorSpacesNamespaceQuery::getSpacesExist()) {
           $fields[] = id(new PhabricatorSearchSpacesField())
             ->setKey('spacePHIDs')
             ->setAliases(array('space', 'spaces'))
             ->setLabel(pht('Spaces'));
         }
       }
     }
 
     foreach ($this->buildCustomFieldSearchFields() as $custom_field) {
       $fields[] = $custom_field;
     }
 
     $query = $this->newQuery();
     if ($query) {
       $orders = $query->getBuiltinOrders();
       $orders = ipull($orders, 'name');
 
       $fields[] = id(new PhabricatorSearchOrderField())
         ->setLabel(pht('Order'))
         ->setKey('order')
         ->setOptions($orders);
     }
 
     $field_map = array();
     foreach ($fields as $field) {
       $key = $field->getKey();
       if (isset($field_map[$key])) {
         throw new Exception(
           pht(
             'Two fields in this SearchEngine use the same key ("%s"), but '.
             'each field must use a unique key.',
             $key));
       }
       $field_map[$key] = $field;
     }
 
     return $this->adjustFieldsForDisplay($field_map);
   }
 
   private function adjustFieldsForDisplay(array $field_map) {
     $order = $this->getDefaultFieldOrder();
 
     $head_keys = array();
     $tail_keys = array();
     $seen_tail = false;
     foreach ($order as $order_key) {
       if ($order_key === '...') {
         $seen_tail = true;
         continue;
       }
 
       if (!$seen_tail) {
         $head_keys[] = $order_key;
       } else {
         $tail_keys[] = $order_key;
       }
     }
 
     $head = array_select_keys($field_map, $head_keys);
     $body = array_diff_key($field_map, array_fuse($tail_keys));
     $tail = array_select_keys($field_map, $tail_keys);
 
     return $head + $body + $tail;
   }
 
   protected function buildCustomSearchFields() {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * Define the default display order for fields by returning a list of
    * field keys.
    *
    * You can use the special key `...` to mean "all unspecified fields go
    * here". This lets you easily put important fields at the top of the form,
    * standard fields in the middle of the form, and less important fields at
    * the bottom.
    *
    * For example, you might return a list like this:
    *
    *   return array(
    *     'authorPHIDs',
    *     'reviewerPHIDs',
    *     '...',
    *     'createdAfter',
    *     'createdBefore',
    *   );
    *
    * Any unspecified fields (including custom fields and fields added
    * automatically by infrastruture) will be put in the middle.
    *
    * @return list<string> Default ordering for field keys.
    */
   protected function getDefaultFieldOrder() {
     return array();
   }
 
   public function getErrors() {
     return $this->errors;
   }
 
   public function addError($error) {
     $this->errors[] = $error;
     return $this;
   }
 
   /**
    * Return an application URI corresponding to the results page of a query.
    * Normally, this is something like `/application/query/QUERYKEY/`.
    *
    * @param   string  The query key to build a URI for.
    * @return  string  URI where the query can be executed.
    * @task uri
    */
   public function getQueryResultsPageURI($query_key) {
     return $this->getURI('query/'.$query_key.'/');
   }
 
 
   /**
    * Return an application URI for query management. This is used when, e.g.,
    * a query deletion operation is cancelled.
    *
    * @return  string  URI where queries can be managed.
    * @task uri
    */
   public function getQueryManagementURI() {
     return $this->getURI('query/edit/');
   }
 
 
   /**
    * Return the URI to a path within the application. Used to construct default
    * URIs for management and results.
    *
    * @return string URI to path.
    * @task uri
    */
   abstract protected function getURI($path);
 
 
   /**
    * Return a human readable description of the type of objects this query
    * searches for.
    *
    * For example, "Tasks" or "Commits".
    *
    * @return string Human-readable description of what this engine is used to
    *   find.
    */
   abstract public function getResultTypeDescription();
 
 
   public function newSavedQuery() {
     return id(new PhabricatorSavedQuery())
       ->setEngineClassName(get_class($this));
   }
 
   public function addNavigationItems(PHUIListView $menu) {
     $viewer = $this->requireViewer();
 
     $menu->newLabel(pht('Queries'));
 
     $named_queries = $this->loadEnabledNamedQueries();
 
     foreach ($named_queries as $query) {
       $key = $query->getQueryKey();
       $uri = $this->getQueryResultsPageURI($key);
       $menu->newLink($query->getQueryName(), $uri, 'query/'.$key);
     }
 
     if ($viewer->isLoggedIn()) {
       $manage_uri = $this->getQueryManagementURI();
       $menu->newLink(pht('Edit Queries...'), $manage_uri, 'query/edit');
     }
 
     $menu->newLabel(pht('Search'));
     $advanced_uri = $this->getQueryResultsPageURI('advanced');
     $menu->newLink(pht('Advanced Search'), $advanced_uri, 'query/advanced');
 
     return $this;
   }
 
   public function loadAllNamedQueries() {
     $viewer = $this->requireViewer();
 
     $named_queries = id(new PhabricatorNamedQueryQuery())
       ->setViewer($viewer)
       ->withUserPHIDs(array($viewer->getPHID()))
       ->withEngineClassNames(array(get_class($this)))
       ->execute();
     $named_queries = mpull($named_queries, null, 'getQueryKey');
 
     $builtin = $this->getBuiltinQueries($viewer);
     $builtin = mpull($builtin, null, 'getQueryKey');
 
     foreach ($named_queries as $key => $named_query) {
       if ($named_query->getIsBuiltin()) {
         if (isset($builtin[$key])) {
           $named_queries[$key]->setQueryName($builtin[$key]->getQueryName());
           unset($builtin[$key]);
         } else {
           unset($named_queries[$key]);
         }
       }
 
       unset($builtin[$key]);
     }
 
     $named_queries = msort($named_queries, 'getSortKey');
 
     return $named_queries + $builtin;
   }
 
   public function loadEnabledNamedQueries() {
     $named_queries = $this->loadAllNamedQueries();
     foreach ($named_queries as $key => $named_query) {
       if ($named_query->getIsBuiltin() && $named_query->getIsDisabled()) {
         unset($named_queries[$key]);
       }
     }
     return $named_queries;
   }
 
   protected function setQueryProjects(
     PhabricatorCursorPagedPolicyAwareQuery $query,
     PhabricatorSavedQuery $saved) {
 
     $datasource = id(new PhabricatorProjectLogicalDatasource())
       ->setViewer($this->requireViewer());
 
     $projects = $saved->getParameter('projects', array());
     $constraints = $datasource->evaluateTokens($projects);
 
     if ($constraints) {
       $query->withEdgeLogicConstraints(
         PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
         $constraints);
     }
   }
 
 
 /* -(  Applications  )------------------------------------------------------- */
 
 
   protected function getApplicationURI($path = '') {
     return $this->getApplication()->getApplicationURI($path);
   }
 
   protected function getApplication() {
     if (!$this->application) {
       $class = $this->getApplicationClassName();
 
       $this->application = id(new PhabricatorApplicationQuery())
         ->setViewer($this->requireViewer())
         ->withClasses(array($class))
         ->withInstalled(true)
         ->executeOne();
 
       if (!$this->application) {
         throw new Exception(
           pht(
             'Application "%s" is not installed!',
             $class));
       }
     }
 
     return $this->application;
   }
 
   abstract public function getApplicationClassName();
 
 
 /* -(  Constructing Engines  )----------------------------------------------- */
 
 
   /**
    * Load all available application search engines.
    *
    * @return list<PhabricatorApplicationSearchEngine> All available engines.
    * @task construct
    */
   public static function getAllEngines() {
     $engines = id(new PhutilSymbolLoader())
       ->setAncestorClass(__CLASS__)
       ->loadObjects();
 
     return $engines;
   }
 
 
   /**
    * Get an engine by class name, if it exists.
    *
    * @return PhabricatorApplicationSearchEngine|null Engine, or null if it does
    *   not exist.
    * @task construct
    */
   public static function getEngineByClassName($class_name) {
     return idx(self::getAllEngines(), $class_name);
   }
 
 
 /* -(  Builtin Queries  )---------------------------------------------------- */
 
 
   /**
    * @task builtin
    */
   public function getBuiltinQueries() {
     $names = $this->getBuiltinQueryNames();
 
     $queries = array();
     $sequence = 0;
     foreach ($names as $key => $name) {
       $queries[$key] = id(new PhabricatorNamedQuery())
         ->setUserPHID($this->requireViewer()->getPHID())
         ->setEngineClassName(get_class($this))
         ->setQueryName($name)
         ->setQueryKey($key)
         ->setSequence((1 << 24) + $sequence++)
         ->setIsBuiltin(true);
     }
 
     return $queries;
   }
 
 
   /**
    * @task builtin
    */
   public function getBuiltinQuery($query_key) {
     if (!$this->isBuiltinQuery($query_key)) {
       throw new Exception(pht("'%s' is not a builtin!", $query_key));
     }
     return idx($this->getBuiltinQueries(), $query_key);
   }
 
 
   /**
    * @task builtin
    */
   protected function getBuiltinQueryNames() {
     return array();
   }
 
 
   /**
    * @task builtin
    */
   public function isBuiltinQuery($query_key) {
     $builtins = $this->getBuiltinQueries();
     return isset($builtins[$query_key]);
   }
 
 
   /**
    * @task builtin
    */
   public function buildSavedQueryFromBuiltin($query_key) {
     throw new Exception(pht("Builtin '%s' is not supported!", $query_key));
   }
 
 
 /* -(  Reading Utilities )--------------------------------------------------- */
 
 
   /**
    * Read a list of user PHIDs from a request in a flexible way. This method
    * supports either of these forms:
    *
    *   users[]=alincoln&users[]=htaft
    *   users=alincoln,htaft
    *
    * Additionally, users can be specified either by PHID or by name.
    *
    * The main goal of this flexibility is to allow external programs to generate
    * links to pages (like "alincoln's open revisions") without needing to make
    * API calls.
    *
    * @param AphrontRequest  Request to read user PHIDs from.
    * @param string          Key to read in the request.
    * @param list<const>     Other permitted PHID types.
    * @return list<phid>     List of user PHIDs and selector functions.
    * @task read
    */
   protected function readUsersFromRequest(
     AphrontRequest $request,
     $key,
     array $allow_types = array()) {
 
     $list = $this->readListFromRequest($request, $key);
 
     $phids = array();
     $names = array();
     $allow_types = array_fuse($allow_types);
     $user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
     foreach ($list as $item) {
       $type = phid_get_type($item);
       if ($type == $user_type) {
         $phids[] = $item;
       } else if (isset($allow_types[$type])) {
         $phids[] = $item;
       } else {
         if (PhabricatorTypeaheadDatasource::isFunctionToken($item)) {
           // If this is a function, pass it through unchanged; we'll evaluate
           // it later.
           $phids[] = $item;
         } else {
           $names[] = $item;
         }
       }
     }
 
     if ($names) {
       $users = id(new PhabricatorPeopleQuery())
         ->setViewer($this->requireViewer())
         ->withUsernames($names)
         ->execute();
       foreach ($users as $user) {
         $phids[] = $user->getPHID();
       }
       $phids = array_unique($phids);
     }
 
     return $phids;
   }
 
 
   /**
    * Read a list of project PHIDs from a request in a flexible way.
    *
    * @param AphrontRequest  Request to read user PHIDs from.
    * @param string          Key to read in the request.
    * @return list<phid>     List of projet PHIDs and selector functions.
    * @task read
    */
   protected function readProjectsFromRequest(AphrontRequest $request, $key) {
     $list = $this->readListFromRequest($request, $key);
 
     $phids = array();
     $slugs = array();
     $project_type = PhabricatorProjectProjectPHIDType::TYPECONST;
     foreach ($list as $item) {
       $type = phid_get_type($item);
       if ($type == $project_type) {
         $phids[] = $item;
       } else {
         if (PhabricatorTypeaheadDatasource::isFunctionToken($item)) {
           // If this is a function, pass it through unchanged; we'll evaluate
           // it later.
           $phids[] = $item;
         } else {
           $slugs[] = $item;
         }
       }
     }
 
     if ($slugs) {
       $projects = id(new PhabricatorProjectQuery())
         ->setViewer($this->requireViewer())
         ->withSlugs($slugs)
         ->execute();
       foreach ($projects as $project) {
         $phids[] = $project->getPHID();
       }
       $phids = array_unique($phids);
     }
 
     return $phids;
   }
 
 
   /**
    * Read a list of subscribers from a request in a flexible way.
    *
    * @param AphrontRequest  Request to read PHIDs from.
    * @param string          Key to read in the request.
    * @return list<phid>     List of object PHIDs.
    * @task read
    */
   protected function readSubscribersFromRequest(
     AphrontRequest $request,
     $key) {
     return $this->readUsersFromRequest(
       $request,
       $key,
       array(
         PhabricatorProjectProjectPHIDType::TYPECONST,
       ));
   }
 
 
   /**
    * Read a list of generic PHIDs from a request in a flexible way. Like
    * @{method:readUsersFromRequest}, this method supports either array or
    * comma-delimited forms. Objects can be specified either by PHID or by
    * object name.
    *
    * @param AphrontRequest  Request to read PHIDs from.
    * @param string          Key to read in the request.
    * @param list<const>     Optional, list of permitted PHID types.
    * @return list<phid>     List of object PHIDs.
    *
    * @task read
    */
   protected function readPHIDsFromRequest(
     AphrontRequest $request,
     $key,
     array $allow_types = array()) {
 
     $list = $this->readListFromRequest($request, $key);
 
     $objects = id(new PhabricatorObjectQuery())
       ->setViewer($this->requireViewer())
       ->withNames($list)
       ->execute();
     $list = mpull($objects, 'getPHID');
 
     if (!$list) {
       return array();
     }
 
     // If only certain PHID types are allowed, filter out all the others.
     if ($allow_types) {
       $allow_types = array_fuse($allow_types);
       foreach ($list as $key => $phid) {
         if (empty($allow_types[phid_get_type($phid)])) {
           unset($list[$key]);
         }
       }
     }
 
     return $list;
   }
 
 
   /**
    * Read a list of items from the request, in either array format or string
    * format:
    *
    *   list[]=item1&list[]=item2
    *   list=item1,item2
    *
    * This provides flexibility when constructing URIs, especially from external
    * sources.
    *
    * @param AphrontRequest  Request to read strings from.
    * @param string          Key to read in the request.
    * @return list<string>   List of values.
    */
   protected function readListFromRequest(
     AphrontRequest $request,
     $key) {
     $list = $request->getArr($key, null);
     if ($list === null) {
       $list = $request->getStrList($key);
     }
 
     if (!$list) {
       return array();
     }
 
     return $list;
   }
 
   protected function readDateFromRequest(
     AphrontRequest $request,
     $key) {
 
     $value = AphrontFormDateControlValue::newFromRequest($request, $key);
 
     if ($value->isEmpty()) {
       return null;
     }
 
     return $value->getDictionary();
   }
 
   protected function readBoolFromRequest(
     AphrontRequest $request,
     $key) {
     if (!strlen($request->getStr($key))) {
       return null;
     }
     return $request->getBool($key);
   }
 
 
   protected function getBoolFromQuery(PhabricatorSavedQuery $query, $key) {
     $value = $query->getParameter($key);
     if ($value === null) {
       return $value;
     }
     return $value ? 'true' : 'false';
   }
 
 
 /* -(  Dates  )-------------------------------------------------------------- */
 
 
   /**
    * @task dates
    */
   protected function parseDateTime($date_time) {
     if (!strlen($date_time)) {
       return null;
     }
 
     return PhabricatorTime::parseLocalTime($date_time, $this->requireViewer());
   }
 
 
   /**
    * @task dates
    */
   protected function buildDateRange(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved_query,
     $start_key,
     $start_name,
     $end_key,
     $end_name) {
 
     $start_str = $saved_query->getParameter($start_key);
     $start = null;
     if (strlen($start_str)) {
       $start = $this->parseDateTime($start_str);
       if (!$start) {
         $this->addError(
           pht(
             '"%s" date can not be parsed.',
             $start_name));
       }
     }
 
 
     $end_str = $saved_query->getParameter($end_key);
     $end = null;
     if (strlen($end_str)) {
       $end = $this->parseDateTime($end_str);
       if (!$end) {
         $this->addError(
           pht(
             '"%s" date can not be parsed.',
             $end_name));
       }
     }
 
     if ($start && $end && ($start >= $end)) {
       $this->addError(
         pht(
           '"%s" must be a date before "%s".',
           $start_name,
           $end_name));
     }
 
     $form
       ->appendChild(
         id(new PHUIFormFreeformDateControl())
           ->setName($start_key)
           ->setLabel($start_name)
           ->setValue($start_str))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setName($end_key)
           ->setLabel($end_name)
           ->setValue($end_str));
   }
 
 
-/* -(  Result Ordering  )---------------------------------------------------- */
-
-  /**
-   * Set query ordering from a saved value.
-   */
-  protected function setQueryOrder(
-    PhabricatorCursorPagedPolicyAwareQuery $query,
-    PhabricatorSavedQuery $saved) {
-
-    $order = $saved->getParameter('order');
-    $builtin = $query->getBuiltinOrders();
-
-    if (strlen($order) && isset($builtin[$order])) {
-      $query->setOrder($order);
-    } else {
-      // If the order is invalid or not available, we choose the first
-      // builtin order. This isn't always the default order for the query,
-      // but is the first value in the "Order" dropdown, and makes the query
-      // behavior more consistent with the UI. In queries where the two
-      // orders differ, this order is the preferred order for humans.
-      $query->setOrder(head_key($builtin));
-    }
-
-    return $this;
-  }
-
-
-
-  protected function appendOrderFieldsToForm(
-    AphrontFormView $form,
-    PhabricatorSavedQuery $saved,
-    PhabricatorCursorPagedPolicyAwareQuery $query) {
-
-    $orders = $query->getBuiltinOrders();
-    $orders = ipull($orders, 'name');
-
-    $form->appendControl(
-      id(new AphrontFormSelectControl())
-        ->setLabel(pht('Order'))
-        ->setName('order')
-        ->setOptions($orders)
-        ->setValue($saved->getParameter('order')));
-  }
-
 /* -(  Paging and Executing Queries  )--------------------------------------- */
 
 
   public function getPageSize(PhabricatorSavedQuery $saved) {
     return $saved->getParameter('limit', 100);
   }
 
 
   public function shouldUseOffsetPaging() {
     return false;
   }
 
 
   public function newPagerForSavedQuery(PhabricatorSavedQuery $saved) {
     if ($this->shouldUseOffsetPaging()) {
       $pager = new AphrontPagerView();
     } else {
       $pager = new AphrontCursorPagerView();
     }
 
     $page_size = $this->getPageSize($saved);
     if (is_finite($page_size)) {
       $pager->setPageSize($page_size);
     } else {
       // Consider an INF pagesize to mean a large finite pagesize.
 
       // TODO: It would be nice to handle this more gracefully, but math
       // with INF seems to vary across PHP versions, systems, and runtimes.
       $pager->setPageSize(0xFFFF);
     }
 
     return $pager;
   }
 
 
   public function executeQuery(
     PhabricatorPolicyAwareQuery $query,
     AphrontView $pager) {
 
     $query->setViewer($this->requireViewer());
 
     if ($this->shouldUseOffsetPaging()) {
       $objects = $query->executeWithOffsetPager($pager);
     } else {
       $objects = $query->executeWithCursorPager($pager);
     }
 
     return $objects;
   }
 
 
 /* -(  Rendering  )---------------------------------------------------------- */
 
 
   public function setRequest(AphrontRequest $request) {
     $this->request = $request;
     return $this;
   }
 
   public function getRequest() {
     return $this->request;
   }
 
   public function renderResults(
     array $objects,
     PhabricatorSavedQuery $query) {
 
     $phids = $this->getRequiredHandlePHIDsForResultList($objects, $query);
 
     if ($phids) {
       $handles = id(new PhabricatorHandleQuery())
         ->setViewer($this->requireViewer())
         ->witHPHIDs($phids)
         ->execute();
     } else {
       $handles = array();
     }
 
     return $this->renderResultList($objects, $query, $handles);
   }
 
   protected function getRequiredHandlePHIDsForResultList(
     array $objects,
     PhabricatorSavedQuery $query) {
     return array();
   }
 
   protected function renderResultList(
     array $objects,
     PhabricatorSavedQuery $query,
     array $handles) {
     throw new Exception(pht('Not supported here yet!'));
   }
 
 
 /* -(  Application Search  )------------------------------------------------- */
 
 
   /**
    * Retrieve an object to use to define custom fields for this search.
    *
    * To integrate with custom fields, subclasses should override this method
    * and return an instance of the application object which implements
    * @{interface:PhabricatorCustomFieldInterface}.
    *
    * @return PhabricatorCustomFieldInterface|null Object with custom fields.
    * @task appsearch
    */
   public function getCustomFieldObject() {
     $object = $this->newResultObject();
     if ($object instanceof PhabricatorCustomFieldInterface) {
       return $object;
     }
     return null;
   }
 
 
   /**
    * Get the custom fields for this search.
    *
    * @return PhabricatorCustomFieldList|null Custom fields, if this search
    *   supports custom fields.
    * @task appsearch
    */
   public function getCustomFieldList() {
     if ($this->customFields === false) {
       $object = $this->getCustomFieldObject();
       if ($object) {
         $fields = PhabricatorCustomField::getObjectFields(
           $object,
           PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
         $fields->setViewer($this->requireViewer());
       } else {
         $fields = null;
       }
       $this->customFields = $fields;
     }
     return $this->customFields;
   }
 
 
   /**
    * Moves data from the request into a saved query.
    *
    * @param AphrontRequest Request to read.
    * @param PhabricatorSavedQuery Query to write to.
    * @return void
    * @task appsearch
    */
   protected function readCustomFieldsFromRequest(
     AphrontRequest $request,
     PhabricatorSavedQuery $saved) {
 
     $list = $this->getCustomFieldList();
     if (!$list) {
       return;
     }
 
     foreach ($list->getFields() as $field) {
       $key = $this->getKeyForCustomField($field);
       $value = $field->readApplicationSearchValueFromRequest(
         $this,
         $request);
       $saved->setParameter($key, $value);
     }
   }
 
 
   /**
    * Applies data from a saved query to an executable query.
    *
    * @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
    * @param PhabricatorSavedQuery Saved query to read.
    * @return void
    */
   protected function applyCustomFieldsToQuery(
     PhabricatorCursorPagedPolicyAwareQuery $query,
     PhabricatorSavedQuery $saved) {
 
     $list = $this->getCustomFieldList();
     if (!$list) {
       return;
     }
 
     foreach ($list->getFields() as $field) {
       $key = $this->getKeyForCustomField($field);
       $value = $field->applyApplicationSearchConstraintToQuery(
         $this,
         $query,
         $saved->getParameter($key));
     }
   }
 
   protected function applyOrderByToQuery(
     PhabricatorCursorPagedPolicyAwareQuery $query,
     array $standard_values,
     $order) {
 
     if (substr($order, 0, 7) === 'custom:') {
       $list = $this->getCustomFieldList();
       if (!$list) {
         $query->setOrderBy(head($standard_values));
         return;
       }
 
       foreach ($list->getFields() as $field) {
         $key = $this->getKeyForCustomField($field);
 
         if ($key === $order) {
           $index = $field->buildOrderIndex();
 
           if ($index === null) {
             $query->setOrderBy(head($standard_values));
             return;
           }
 
           $query->withApplicationSearchOrder(
             $field,
             $index,
             false);
           break;
         }
       }
     } else {
       $order = idx($standard_values, $order);
       if ($order) {
         $query->setOrderBy($order);
       } else {
         $query->setOrderBy(head($standard_values));
       }
     }
   }
 
 
   protected function getCustomFieldOrderOptions() {
     $list = $this->getCustomFieldList();
     if (!$list) {
       return;
     }
 
     $custom_order = array();
     foreach ($list->getFields() as $field) {
       if ($field->shouldAppearInApplicationSearch()) {
         if ($field->buildOrderIndex() !== null) {
           $key = $this->getKeyForCustomField($field);
           $custom_order[$key] = $field->getFieldName();
         }
       }
     }
 
     return $custom_order;
   }
 
   /**
    * Get a unique key identifying a field.
    *
    * @param PhabricatorCustomField Field to identify.
    * @return string Unique identifier, suitable for use as an input name.
    */
   public function getKeyForCustomField(PhabricatorCustomField $field) {
     return 'custom:'.$field->getFieldIndex();
   }
 
   private function buildCustomFieldSearchFields() {
     $list = $this->getCustomFieldList();
     if (!$list) {
       return array();
     }
 
     $fields = array();
     foreach ($list->getFields() as $field) {
       $fields[] = id(new PhabricatorSearchCustomFieldProxyField())
         ->setSearchEngine($this)
         ->setCustomField($field);
     }
     return $fields;
   }
 
   // TODO: Remove.
   protected function appendCustomFieldsToForm(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved) {
 
     $list = $this->getCustomFieldList();
     if (!$list) {
       return;
     }
 
     foreach ($list->getFields() as $field) {
       $key = $this->getKeyForCustomField($field);
       $value = $saved->getParameter($key);
       $field->appendToApplicationSearchForm($this, $form, $value);
     }
   }
 
 }