diff --git a/src/aphront/configuration/AphrontDefaultApplicationConfiguration.php b/src/aphront/configuration/AphrontDefaultApplicationConfiguration.php
index 7126f63995..e047e17b3f 100644
--- a/src/aphront/configuration/AphrontDefaultApplicationConfiguration.php
+++ b/src/aphront/configuration/AphrontDefaultApplicationConfiguration.php
@@ -1,371 +1,385 @@
 <?php
 
 /**
  * @group aphront
  */
 class AphrontDefaultApplicationConfiguration
   extends AphrontApplicationConfiguration {
 
   public function __construct() {
 
   }
 
   public function getApplicationName() {
     return 'aphront-default';
   }
 
   public function getURIMap() {
     return $this->getResourceURIMapRules() + array(
       '/(?:(?P<filter>(?:jump))/)?' =>
         'PhabricatorDirectoryMainController',
 
       '/typeahead/' => array(
         'common/(?P<type>\w+)/'
           => 'PhabricatorTypeaheadCommonDatasourceController',
       ),
 
       '/oauthserver/' => array(
         'auth/'          => 'PhabricatorOAuthServerAuthController',
         'test/'          => 'PhabricatorOAuthServerTestController',
         'token/'         => 'PhabricatorOAuthServerTokenController',
         'clientauthorization/' => array(
           '' => 'PhabricatorOAuthClientAuthorizationListController',
           'delete/(?P<phid>[^/]+)/' =>
             'PhabricatorOAuthClientAuthorizationDeleteController',
           'edit/(?P<phid>[^/]+)/' =>
             'PhabricatorOAuthClientAuthorizationEditController',
         ),
         'client/' => array(
           ''                        => 'PhabricatorOAuthClientListController',
           'create/'                 => 'PhabricatorOAuthClientEditController',
           'delete/(?P<phid>[^/]+)/' => 'PhabricatorOAuthClientDeleteController',
           'edit/(?P<phid>[^/]+)/'   => 'PhabricatorOAuthClientEditController',
           'view/(?P<phid>[^/]+)/'   => 'PhabricatorOAuthClientViewController',
         ),
       ),
 
       '/~/' => array(
         '' => 'DarkConsoleController',
         'data/(?P<key>[^/]+)/' => 'DarkConsoleDataController',
       ),
 
       '/status/' => 'PhabricatorStatusController',
 
 
       '/help/' => array(
         'keyboardshortcut/' => 'PhabricatorHelpKeyboardShortcutController',
       ),
 
       '/notification/' => array(
         '(?:(?P<filter>all|unread)/)?'
           => 'PhabricatorNotificationListController',
         'panel/' => 'PhabricatorNotificationPanelController',
         'individual/' => 'PhabricatorNotificationIndividualController',
         'status/' => 'PhabricatorNotificationStatusController',
         'clear/' => 'PhabricatorNotificationClearController',
       ),
 
       '/debug/' => 'PhabricatorDebugController',
     );
   }
 
   protected function getResourceURIMapRules() {
     return array(
       '/res/' => array(
         '(?:(?P<mtime>[0-9]+)T/)?'.
         '(?P<package>pkg/)?'.
         '(?P<hash>[a-f0-9]{8})/'.
         '(?P<path>.+\.(?:css|js|jpg|png|swf|gif))'
           => 'CelerityPhabricatorResourceController',
       ),
     );
   }
 
   /**
    * @phutil-external-symbol class PhabricatorStartup
    */
   public function buildRequest() {
     $parser = new PhutilQueryStringParser();
     $data   = array();
 
     // If the request has "multipart/form-data" content, we can't use
     // PhutilQueryStringParser to parse it, and the raw data supposedly is not
     // available anyway (according to the PHP documentation, "php://input" is
     // not available for "multipart/form-data" requests). However, it is
     // available at least some of the time (see T3673), so double check that
     // we aren't trying to parse data we won't be able to parse correctly by
     // examining the Content-Type header.
     $content_type = idx($_SERVER, 'CONTENT_TYPE');
     $is_form_data = preg_match('@^multipart/form-data@i', $content_type);
 
     $raw_input = PhabricatorStartup::getRawInput();
     if (strlen($raw_input) && !$is_form_data) {
       $data += $parser->parseQueryString($raw_input);
     } else if ($_POST) {
       $data += $_POST;
     }
 
     $data += $parser->parseQueryString(idx($_SERVER, 'QUERY_STRING', ''));
 
     $request = new AphrontRequest($this->getHost(), $this->getPath());
     $request->setRequestData($data);
     $request->setApplicationConfiguration($this);
 
     return $request;
   }
 
   public function handleException(Exception $ex) {
     $request = $this->getRequest();
 
     // For Conduit requests, return a Conduit response.
     if ($request->isConduit()) {
       $response = new ConduitAPIResponse();
       $response->setErrorCode(get_class($ex));
       $response->setErrorInfo($ex->getMessage());
 
       return id(new AphrontJSONResponse())
         ->setAddJSONShield(false)
         ->setContent($response->toDictionary());
     }
 
     // For non-workflow requests, return a Ajax response.
     if ($request->isAjax() && !$request->isJavelinWorkflow()) {
       // Log these; they don't get shown on the client and can be difficult
       // to debug.
       phlog($ex);
 
       $response = new AphrontAjaxResponse();
       $response->setError(
         array(
           'code' => get_class($ex),
           'info' => $ex->getMessage(),
         ));
       return $response;
     }
 
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     $user = $request->getUser();
     if (!$user) {
       // If we hit an exception very early, we won't have a user.
       $user = new PhabricatorUser();
     }
 
     if ($ex instanceof PhabricatorPolicyException) {
 
       if (!$user->isLoggedIn()) {
         // If the user isn't logged in, just give them a login form. This is
         // probably a generally more useful response than a policy dialog that
         // they have to click through to get a login form.
         //
         // Possibly we should add a header here like "you need to login to see
         // the thing you are trying to look at".
         $login_controller = new PhabricatorAuthStartController($request);
         return $login_controller->processRequest();
       }
 
-      $content = hsprintf(
-        '<div class="aphront-policy-exception">%s</div>',
-        $ex->getMessage());
+      $list = $ex->getMoreInfo();
+      foreach ($list as $key => $item) {
+        $list[$key] = phutil_tag('li', array(), $item);
+      }
+      if ($list) {
+        $list = phutil_tag('ul', array(), $list);
+      }
+
+      $content = phutil_tag(
+        'div',
+        array(
+          'class' => 'aphront-policy-exception',
+        ),
+        array(
+          $ex->getMessage(),
+          $list,
+        ));
 
       $dialog = new AphrontDialogView();
       $dialog
         ->setTitle(
             $is_serious
               ? 'Access Denied'
               : "You Shall Not Pass")
         ->setClass('aphront-access-dialog')
         ->setUser($user)
         ->appendChild($content);
 
       if ($this->getRequest()->isAjax()) {
         $dialog->addCancelButton('/', 'Close');
       } else {
         $dialog->addCancelButton('/', $is_serious ? 'OK' : 'Away With Thee');
       }
 
       $response = new AphrontDialogResponse();
       $response->setDialog($dialog);
       return $response;
     }
 
     if ($ex instanceof AphrontUsageException) {
       $error = new AphrontErrorView();
       $error->setTitle($ex->getTitle());
       $error->appendChild($ex->getMessage());
 
       $view = new PhabricatorStandardPageView();
       $view->setRequest($this->getRequest());
       $view->appendChild($error);
 
       $response = new AphrontWebpageResponse();
       $response->setContent($view->render());
 
       return $response;
     }
 
 
     // Always log the unhandled exception.
     phlog($ex);
 
     $class    = get_class($ex);
     $message  = $ex->getMessage();
 
     if ($ex instanceof AphrontQuerySchemaException) {
       $message .=
         "\n\n".
         "NOTE: This usually indicates that the MySQL schema has not been ".
         "properly upgraded. Run 'bin/storage upgrade' to ensure your ".
         "schema is up to date.";
     }
 
     if (PhabricatorEnv::getEnvConfig('phabricator.developer-mode')) {
       $trace = $this->renderStackTrace($ex->getTrace(), $user);
     } else {
       $trace = null;
     }
 
     $content = hsprintf(
       '<div class="aphront-unhandled-exception">'.
         '<div class="exception-message">%s</div>'.
         '%s'.
       '</div>',
       $message,
       $trace);
 
     $dialog = new AphrontDialogView();
     $dialog
       ->setTitle('Unhandled Exception ("'.$class.'")')
       ->setClass('aphront-exception-dialog')
       ->setUser($user)
       ->appendChild($content);
 
     if ($this->getRequest()->isAjax()) {
       $dialog->addCancelButton('/', 'Close');
     }
 
     $response = new AphrontDialogResponse();
     $response->setDialog($dialog);
 
     return $response;
   }
 
   public function willSendResponse(AphrontResponse $response) {
     return $response;
   }
 
   public function build404Controller() {
     return array(new Phabricator404Controller($this->getRequest()), array());
   }
 
   public function buildRedirectController($uri) {
     return array(
       new PhabricatorRedirectController($this->getRequest()),
       array(
         'uri' => $uri,
       ));
   }
 
   private function renderStackTrace($trace, PhabricatorUser $user) {
 
     $libraries = PhutilBootloader::getInstance()->getAllLibraries();
 
     // TODO: Make this configurable?
     $path = 'https://secure.phabricator.com/diffusion/%s/browse/master/src/';
 
     $callsigns = array(
       'arcanist' => 'ARC',
       'phutil' => 'PHU',
       'phabricator' => 'P',
     );
 
     $rows = array();
     $depth = count($trace);
     foreach ($trace as $part) {
       $lib = null;
       $file = idx($part, 'file');
       $relative = $file;
       foreach ($libraries as $library) {
         $root = phutil_get_library_root($library);
         if (Filesystem::isDescendant($file, $root)) {
           $lib = $library;
           $relative = Filesystem::readablePath($file, $root);
           break;
         }
       }
 
       $where = '';
       if (isset($part['class'])) {
         $where .= $part['class'].'::';
       }
       if (isset($part['function'])) {
         $where .= $part['function'].'()';
       }
 
       if ($file) {
         if (isset($callsigns[$lib])) {
           $attrs = array('title' => $file);
           try {
             $attrs['href'] = $user->loadEditorLink(
               '/src/'.$relative,
               $part['line'],
               $callsigns[$lib]);
           } catch (Exception $ex) {
             // The database can be inaccessible.
           }
           if (empty($attrs['href'])) {
             $attrs['href'] = sprintf($path, $callsigns[$lib]).
               str_replace(DIRECTORY_SEPARATOR, '/', $relative).
               '$'.$part['line'];
             $attrs['target'] = '_blank';
           }
           $file_name = phutil_tag(
             'a',
             $attrs,
             $relative);
         } else {
           $file_name = phutil_tag(
             'span',
             array(
               'title' => $file,
             ),
             $relative);
         }
         $file_name = hsprintf('%s : %d', $file_name, $part['line']);
       } else {
         $file_name = phutil_tag('em', array(), '(Internal)');
       }
 
 
       $rows[] = array(
         $depth--,
         $lib,
         $file_name,
         $where,
       );
     }
     $table = new AphrontTableView($rows);
     $table->setHeaders(
       array(
         'Depth',
         'Library',
         'File',
         'Where',
       ));
     $table->setColumnClasses(
       array(
         'n',
         '',
         '',
         'wide',
       ));
 
     return hsprintf(
       '<div class="exception-trace">'.
         '<div class="exception-trace-header">Stack Trace</div>'.
         '%s'.
       '</div>',
       $table->render());
   }
 
 }
diff --git a/src/applications/differential/query/DifferentialRevisionQuery.php b/src/applications/differential/query/DifferentialRevisionQuery.php
index 6a2a4133c9..fb36174a47 100644
--- a/src/applications/differential/query/DifferentialRevisionQuery.php
+++ b/src/applications/differential/query/DifferentialRevisionQuery.php
@@ -1,1050 +1,1054 @@
 <?php
 
 /**
  * Flexible query API for Differential revisions. Example:
  *
  *   // Load open revisions
  *   $revisions = id(new DifferentialRevisionQuery())
  *     ->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
  *     ->execute();
  *
  * @task config   Query Configuration
  * @task exec     Query Execution
  * @task internal Internals
  */
 final class DifferentialRevisionQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $pathIDs = array();
 
   private $status             = 'status-any';
   const STATUS_ANY            = 'status-any';
   const STATUS_OPEN           = 'status-open';
   const STATUS_ACCEPTED       = 'status-accepted';
   const STATUS_NEEDS_REVIEW   = 'status-needs-review';
   const STATUS_NEEDS_REVISION = 'status-needs-revision';
   const STATUS_CLOSED         = 'status-closed';    // NOTE: Same as 'committed'
   const STATUS_COMMITTED      = 'status-committed'; // TODO: Remove.
   const STATUS_ABANDONED      = 'status-abandoned';
 
   private $authors = array();
   private $draftAuthors = array();
   private $ccs = array();
   private $reviewers = array();
   private $revIDs = array();
   private $commitHashes = array();
   private $phids = array();
   private $subscribers = array();
   private $responsibles = array();
   private $branches = array();
   private $arcanistProjectPHIDs = array();
   private $draftRevisions = array();
   private $repositoryPHIDs;
 
   private $order            = 'order-modified';
   const ORDER_MODIFIED      = 'order-modified';
   const ORDER_CREATED       = 'order-created';
   /**
    * This is essentially a denormalized copy of the revision modified time that
    * should perform better for path queries with a LIMIT. Critically, when you
    * browse "/", every revision in that repository for all time will match so
    * the query benefits from being able to stop before fully materializing the
    * result set.
    */
   const ORDER_PATH_MODIFIED = 'order-path-modified';
 
   private $needRelationships  = false;
   private $needActiveDiffs    = false;
   private $needDiffIDs        = false;
   private $needCommitPHIDs    = false;
   private $needHashes         = false;
   private $needReviewerStatus = false;
 
   private $buildingGlobalOrder;
 
 
 /* -(  Query Configuration  )------------------------------------------------ */
 
 
   /**
    * Filter results to revisions which affect a Diffusion path ID in a given
    * repository. You can call this multiple times to select revisions for
    * several paths.
    *
    * @param int Diffusion repository ID.
    * @param int Diffusion path ID.
    * @return this
    * @task config
    */
   public function withPath($repository_id, $path_id) {
     $this->pathIDs[] = array(
       'repositoryID' => $repository_id,
       'pathID'       => $path_id,
     );
     return $this;
   }
 
   /**
    * Filter results to revisions authored by one of the given PHIDs. Calling
    * this function will clear anything set by previous calls to
    * @{method:withAuthors}.
    *
    * @param array List of PHIDs of authors
    * @return this
    * @task config
    */
   public function withAuthors(array $author_phids) {
     $this->authors = $author_phids;
     return $this;
   }
 
   /**
    * Filter results to revisions with comments authored bythe given PHIDs
    *
    * @param array List of PHIDs of authors
    * @return this
    * @task config
    */
   public function withDraftRepliesByAuthors(array $author_phids) {
     $this->draftAuthors = $author_phids;
     return $this;
   }
 
   /**
    * Filter results to revisions which CC one of the listed people. Calling this
    * function will clear anything set by previous calls to @{method:withCCs}.
    *
    * @param array List of PHIDs of subscribers
    * @return this
    * @task config
    */
   public function withCCs(array $cc_phids) {
     $this->ccs = $cc_phids;
     return $this;
   }
 
   /**
    * Filter results to revisions that have one of the provided PHIDs as
    * reviewers. Calling this function will clear anything set by previous calls
    * to @{method:withReviewers}.
    *
    * @param array List of PHIDs of reviewers
    * @return this
    * @task config
    */
   public function withReviewers(array $reviewer_phids) {
     $this->reviewers = $reviewer_phids;
     return $this;
   }
 
   /**
    * Filter results to revisions that have one of the provided commit hashes.
    * Calling this function will clear anything set by previous calls to
    * @{method:withCommitHashes}.
    *
    * @param array List of pairs <Class
    *              ArcanistDifferentialRevisionHash::HASH_$type constant,
    *              hash>
    * @return this
    * @task config
    */
   public function withCommitHashes(array $commit_hashes) {
     $this->commitHashes = $commit_hashes;
     return $this;
   }
 
   /**
    * Filter results to revisions with a given status. Provide a class constant,
    * such as ##DifferentialRevisionQuery::STATUS_OPEN##.
    *
    * @param const Class STATUS constant, like STATUS_OPEN.
    * @return this
    * @task config
    */
   public function withStatus($status_constant) {
     $this->status = $status_constant;
     return $this;
   }
 
 
   /**
    * Filter results to revisions on given branches.
    *
    * @param  list List of branch names.
    * @return this
    * @task config
    */
   public function withBranches(array $branches) {
     $this->branches = $branches;
     return $this;
   }
 
 
   /**
    * Filter results to only return revisions whose ids are in the given set.
    *
    * @param array List of revision ids
    * @return this
    * @task config
    */
   public function withIDs(array $ids) {
     $this->revIDs = $ids;
     return $this;
   }
 
 
   /**
    * Filter results to only return revisions whose PHIDs are in the given set.
    *
    * @param array List of revision PHIDs
    * @return this
    * @task config
    */
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
 
   /**
    * Given a set of users, filter results to return only revisions they are
    * responsible for (i.e., they are either authors or reviewers).
    *
    * @param array List of user PHIDs.
    * @return this
    * @task config
    */
   public function withResponsibleUsers(array $responsible_phids) {
     $this->responsibles = $responsible_phids;
     return $this;
   }
 
 
   /**
    * Filter results to only return revisions with a given set of subscribers
    * (i.e., they are authors, reviewers or CC'd).
    *
    * @param array List of user PHIDs.
    * @return this
    * @task config
    */
   public function withSubscribers(array $subscriber_phids) {
     $this->subscribers = $subscriber_phids;
     return $this;
   }
 
 
   /**
    * Filter results to only return revisions with a given set of arcanist
    * projects.
    *
    * @param array List of project PHIDs.
    * @return this
    * @task config
    */
   public function withArcanistProjectPHIDs(array $arc_project_phids) {
     $this->arcanistProjectPHIDs = $arc_project_phids;
     return $this;
   }
 
   public function withRepositoryPHIDs(array $repository_phids) {
     $this->repositoryPHIDs = $repository_phids;
     return $this;
   }
 
 
   /**
    * Set result ordering. Provide a class constant, such as
    * ##DifferentialRevisionQuery::ORDER_CREATED##.
    *
    * @task config
    */
   public function setOrder($order_constant) {
     $this->order = $order_constant;
     return $this;
   }
 
 
   /**
    * Set whether or not the query will load and attach relationships.
    *
    * @param bool True to load and attach relationships.
    * @return this
    * @task config
    */
   public function needRelationships($need_relationships) {
     $this->needRelationships = $need_relationships;
     return $this;
   }
 
 
   /**
    * Set whether or not the query should load the active diff for each
    * revision.
    *
    * @param bool True to load and attach diffs.
    * @return this
    * @task config
    */
   public function needActiveDiffs($need_active_diffs) {
     $this->needActiveDiffs = $need_active_diffs;
     return $this;
   }
 
 
   /**
    * Set whether or not the query should load the associated commit PHIDs for
    * each revision.
    *
    * @param bool True to load and attach diffs.
    * @return this
    * @task config
    */
   public function needCommitPHIDs($need_commit_phids) {
     $this->needCommitPHIDs = $need_commit_phids;
     return $this;
   }
 
 
   /**
    * Set whether or not the query should load associated diff IDs for each
    * revision.
    *
    * @param bool True to load and attach diff IDs.
    * @return this
    * @task config
    */
   public function needDiffIDs($need_diff_ids) {
     $this->needDiffIDs = $need_diff_ids;
     return $this;
   }
 
 
   /**
    * Set whether or not the query should load associated commit hashes for each
    * revision.
    *
    * @param bool True to load and attach commit hashes.
    * @return this
    * @task config
    */
   public function needHashes($need_hashes) {
     $this->needHashes = $need_hashes;
     return $this;
   }
 
 
   /**
    * Set whether or not the query should load associated reviewer status.
    *
    * @param bool True to load and attach reviewers.
    * @return this
    * @task config
    */
   public function needReviewerStatus($need_reviewer_status) {
     $this->needReviewerStatus = $need_reviewer_status;
     return $this;
   }
 
 
 /* -(  Query Execution  )---------------------------------------------------- */
 
 
   /**
    * Execute the query as configured, returning matching
    * @{class:DifferentialRevision} objects.
    *
    * @return list List of matching DifferentialRevision objects.
    * @task exec
    */
   public function loadPage() {
     $table = new DifferentialRevision();
     $conn_r = $table->establishConnection('r');
 
     $data = $this->loadData();
 
     return $table->loadAllFromArray($data);
   }
 
   public function willFilterPage(array $revisions) {
     $viewer = $this->getViewer();
 
     $repository_phids = mpull($revisions, 'getRepositoryPHID');
     $repository_phids = array_filter($repository_phids);
 
     $repositories = array();
     if ($repository_phids) {
       $repositories = id(new PhabricatorRepositoryQuery())
         ->setViewer($this->getViewer())
         ->withPHIDs($repository_phids)
         ->execute();
       $repositories = mpull($repositories, null, 'getPHID');
     }
 
     // If a revision is associated with a repository:
     //
     //   - the viewer must be able to see the repository; or
     //   - the viewer must have an automatic view capability.
     //
     // In the latter case, we'll load the revision but not load the repository.
 
     $can_view = PhabricatorPolicyCapability::CAN_VIEW;
     foreach ($revisions as $key => $revision) {
       $repo_phid = $revision->getRepositoryPHID();
       if (!$repo_phid) {
         // The revision has no associated repository. Attach `null` and move on.
         $revision->attachRepository(null);
         continue;
       }
 
       $repository = idx($repositories, $repo_phid);
       if ($repository) {
         // The revision has an associated repository, and the viewer can see
         // it. Attach it and move on.
         $revision->attachRepository($repository);
         continue;
       }
 
       if ($revision->hasAutomaticCapability($can_view, $viewer)) {
         // The revision has an associated repository which the viewer can not
         // see, but the viewer has an automatic capability on this revision.
         // Load the revision without attaching a repository.
         $revision->attachRepository(null);
         continue;
       }
 
       // The revision has an associated repository, and the viewer can't see
       // it, and the viewer has no special capabilities. Filter out this
       // revision.
+      $this->didRejectResult($revision);
       unset($revisions[$key]);
     }
 
+    if (!$revisions) {
+      return array();
+    }
 
     $table = new DifferentialRevision();
     $conn_r = $table->establishConnection('r');
 
     if ($this->needRelationships) {
       $this->loadRelationships($conn_r, $revisions);
     }
 
     if ($this->needCommitPHIDs) {
       $this->loadCommitPHIDs($conn_r, $revisions);
     }
 
     $need_active = $this->needActiveDiffs;
     $need_ids = $need_active || $this->needDiffIDs;
 
     if ($need_ids) {
       $this->loadDiffIDs($conn_r, $revisions);
     }
 
     if ($need_active) {
       $this->loadActiveDiffs($conn_r, $revisions);
     }
 
     if ($this->needHashes) {
       $this->loadHashes($conn_r, $revisions);
     }
 
     if ($this->needReviewerStatus) {
       $this->loadReviewers($conn_r, $revisions);
     }
 
     return $revisions;
   }
 
   private function loadData() {
     $table = new DifferentialRevision();
     $conn_r = $table->establishConnection('r');
 
     if ($this->draftAuthors) {
       $this->draftRevisions = array();
 
       $draft_key = 'differential-comment-';
       $drafts = id(new PhabricatorDraft())->loadAllWhere(
         'authorPHID IN (%Ls) AND draftKey LIKE %> AND draft != %s',
         $this->draftAuthors,
         $draft_key,
         '');
       $len = strlen($draft_key);
       foreach ($drafts as $draft) {
         $this->draftRevisions[] = substr($draft->getDraftKey(), $len);
       }
 
       $inlines = id(new DifferentialInlineCommentQuery())
         ->withDraftsByAuthors($this->draftAuthors)
         ->execute();
       foreach ($inlines as $inline) {
         $this->draftRevisions[] = $inline->getRevisionID();
       }
 
       if (!$this->draftRevisions) {
         return array();
       }
     }
 
     $selects = array();
 
     // NOTE: If the query includes "responsiblePHIDs", we execute it as a
     // UNION of revisions they own and revisions they're reviewing. This has
     // much better performance than doing it with JOIN/WHERE.
     if ($this->responsibles) {
       $basic_authors = $this->authors;
       $basic_reviewers = $this->reviewers;
       try {
         // Build the query where the responsible users are authors.
         $this->authors = array_merge($basic_authors, $this->responsibles);
         $this->reviewers = $basic_reviewers;
         $selects[] = $this->buildSelectStatement($conn_r);
 
         // Build the query where the responsible users are reviewers.
         $this->authors = $basic_authors;
         $this->reviewers = array_merge($basic_reviewers, $this->responsibles);
         $selects[] = $this->buildSelectStatement($conn_r);
 
         // Put everything back like it was.
         $this->authors = $basic_authors;
         $this->reviewers = $basic_reviewers;
       } catch (Exception $ex) {
         $this->authors = $basic_authors;
         $this->reviewers = $basic_reviewers;
         throw $ex;
       }
     } else {
       $selects[] = $this->buildSelectStatement($conn_r);
     }
 
     if (count($selects) > 1) {
       $this->buildingGlobalOrder = true;
       $query = qsprintf(
         $conn_r,
         '%Q %Q %Q',
         implode(' UNION DISTINCT ', $selects),
         $this->buildOrderClause($conn_r),
         $this->buildLimitClause($conn_r));
     } else {
       $query = head($selects);
     }
 
     return queryfx_all($conn_r, '%Q', $query);
   }
 
   private function buildSelectStatement(AphrontDatabaseConnection $conn_r) {
     $table = new DifferentialRevision();
 
     $select = qsprintf(
       $conn_r,
       'SELECT r.* FROM %T r',
       $table->getTableName());
 
     $joins = $this->buildJoinsClause($conn_r);
     $where = $this->buildWhereClause($conn_r);
     $group_by = $this->buildGroupByClause($conn_r);
 
     $this->buildingGlobalOrder = false;
     $order_by = $this->buildOrderClause($conn_r);
 
     $limit = $this->buildLimitClause($conn_r);
 
     return qsprintf(
       $conn_r,
       '(%Q %Q %Q %Q %Q %Q)',
       $select,
       $joins,
       $where,
       $group_by,
       $order_by,
       $limit);
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * @task internal
    */
   private function buildJoinsClause($conn_r) {
     $joins = array();
     if ($this->pathIDs) {
       $path_table = new DifferentialAffectedPath();
       $joins[] = qsprintf(
         $conn_r,
         'JOIN %T p ON p.revisionID = r.id',
         $path_table->getTableName());
     }
 
     if ($this->commitHashes) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN %T hash_rel ON hash_rel.revisionID = r.id',
         ArcanistDifferentialRevisionHash::TABLE_NAME);
     }
 
     if ($this->ccs) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN %T cc_rel ON cc_rel.revisionID = r.id '.
         'AND cc_rel.relation = %s '.
         'AND cc_rel.objectPHID in (%Ls)',
         DifferentialRevision::RELATIONSHIP_TABLE,
         DifferentialRevision::RELATION_SUBSCRIBED,
         $this->ccs);
     }
 
     if ($this->reviewers) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN %T reviewer_rel ON reviewer_rel.revisionID = r.id '.
         'AND reviewer_rel.relation = %s '.
         'AND reviewer_rel.objectPHID in (%Ls)',
         DifferentialRevision::RELATIONSHIP_TABLE,
         DifferentialRevision::RELATION_REVIEWER,
         $this->reviewers);
     }
 
     if ($this->subscribers) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN %T sub_rel ON sub_rel.revisionID = r.id '.
         'AND sub_rel.relation IN (%Ls) '.
         'AND sub_rel.objectPHID in (%Ls)',
         DifferentialRevision::RELATIONSHIP_TABLE,
         array(
           DifferentialRevision::RELATION_SUBSCRIBED,
           DifferentialRevision::RELATION_REVIEWER,
         ),
         $this->subscribers);
     }
 
     $joins = implode(' ', $joins);
 
     return $joins;
   }
 
 
   /**
    * @task internal
    */
   private function buildWhereClause($conn_r) {
     $where = array();
 
     if ($this->pathIDs) {
       $path_clauses = array();
       $repo_info = igroup($this->pathIDs, 'repositoryID');
       foreach ($repo_info as $repository_id => $paths) {
         $path_clauses[] = qsprintf(
           $conn_r,
           '(p.repositoryID = %d AND p.pathID IN (%Ld))',
           $repository_id,
           ipull($paths, 'pathID'));
       }
       $path_clauses = '('.implode(' OR ', $path_clauses).')';
       $where[] = $path_clauses;
     }
 
     if ($this->authors) {
       $where[] = qsprintf(
         $conn_r,
         'r.authorPHID IN (%Ls)',
         $this->authors);
     }
 
     if ($this->draftRevisions) {
       $where[] = qsprintf(
         $conn_r,
         'r.id IN (%Ld)',
         $this->draftRevisions);
     }
 
     if ($this->revIDs) {
       $where[] = qsprintf(
         $conn_r,
         'r.id IN (%Ld)',
         $this->revIDs);
     }
 
     if ($this->repositoryPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'r.repositoryPHID IN (%Ls)',
         $this->repositoryPHIDs);
     }
 
     if ($this->commitHashes) {
       $hash_clauses = array();
       foreach ($this->commitHashes as $info) {
         list($type, $hash) = $info;
         $hash_clauses[] = qsprintf(
           $conn_r,
           '(hash_rel.type = %s AND hash_rel.hash = %s)',
           $type,
           $hash);
       }
       $hash_clauses = '('.implode(' OR ', $hash_clauses).')';
       $where[] = $hash_clauses;
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn_r,
         'r.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->branches) {
       $where[] = qsprintf(
         $conn_r,
         'r.branchName in (%Ls)',
         $this->branches);
     }
 
     if ($this->arcanistProjectPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'r.arcanistProjectPHID in (%Ls)',
         $this->arcanistProjectPHIDs);
     }
 
     switch ($this->status) {
       case self::STATUS_ANY:
         break;
       case self::STATUS_OPEN:
         $where[] = qsprintf(
           $conn_r,
           'r.status IN (%Ld)',
           array(
             ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
             ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
             ArcanistDifferentialRevisionStatus::ACCEPTED,
           ));
         break;
       case self::STATUS_NEEDS_REVIEW:
         $where[] = qsprintf(
           $conn_r,
           'r.status IN (%Ld)',
           array(
                ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
           ));
         break;
       case self::STATUS_NEEDS_REVISION:
         $where[] = qsprintf(
           $conn_r,
           'r.status IN (%Ld)',
           array(
                ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
           ));
         break;
       case self::STATUS_ACCEPTED:
         $where[] = qsprintf(
           $conn_r,
           'r.status IN (%Ld)',
           array(
             ArcanistDifferentialRevisionStatus::ACCEPTED,
           ));
         break;
       case self::STATUS_COMMITTED:
         phlog(
           "WARNING: DifferentialRevisionQuery using deprecated ".
           "STATUS_COMMITTED constant. This will be removed soon. ".
           "Use STATUS_CLOSED.");
         // fallthrough
       case self::STATUS_CLOSED:
         $where[] = qsprintf(
           $conn_r,
           'r.status IN (%Ld)',
           array(
             ArcanistDifferentialRevisionStatus::CLOSED,
           ));
         break;
       case self::STATUS_ABANDONED:
         $where[] = qsprintf(
           $conn_r,
           'r.status IN (%Ld)',
           array(
             ArcanistDifferentialRevisionStatus::ABANDONED,
           ));
         break;
       default:
         throw new Exception(
           "Unknown revision status filter constant '{$this->status}'!");
     }
 
     $where[] = $this->buildPagingClause($conn_r);
     return $this->formatWhereClause($where);
   }
 
 
   /**
    * @task internal
    */
   private function buildGroupByClause($conn_r) {
     $join_triggers = array_merge(
       $this->pathIDs,
       $this->ccs,
       $this->reviewers,
       $this->subscribers);
 
     $needs_distinct = (count($join_triggers) > 1);
 
     if ($needs_distinct) {
       return 'GROUP BY r.id';
     } else {
       return '';
     }
   }
 
   private function loadCursorObject($id) {
     $results = id(new DifferentialRevisionQuery())
       ->setViewer($this->getPagingViewer())
       ->withIDs(array((int)$id))
       ->execute();
     return head($results);
   }
 
   protected function buildPagingClause(AphrontDatabaseConnection $conn_r) {
     $default = parent::buildPagingClause($conn_r);
 
     $before_id = $this->getBeforeID();
     $after_id = $this->getAfterID();
 
     if (!$before_id && !$after_id) {
       return $default;
     }
 
     if ($before_id) {
       $cursor = $this->loadCursorObject($before_id);
     } else {
       $cursor = $this->loadCursorObject($after_id);
     }
 
     if (!$cursor) {
       return null;
     }
 
     $columns = array();
 
     switch ($this->order) {
       case self::ORDER_CREATED:
         return $default;
       case self::ORDER_MODIFIED:
         $columns[] = array(
           'name' => 'r.dateModified',
           'value' => $cursor->getDateModified(),
           'type' => 'int',
         );
         break;
       case self::ORDER_PATH_MODIFIED:
         $columns[] = array(
           'name' => 'p.epoch',
           'value' => $cursor->getDateCreated(),
           'type' => 'int',
         );
         break;
     }
 
     $columns[] = array(
       'name' => 'r.id',
       'value' => $cursor->getID(),
       'type' => 'int',
     );
 
     return $this->buildPagingClauseFromMultipleColumns(
       $conn_r,
       $columns,
       array(
         'reversed' => (bool)($before_id xor $this->getReversePaging()),
       ));
   }
 
   protected function getPagingColumn() {
     $is_global = $this->buildingGlobalOrder;
     switch ($this->order) {
       case self::ORDER_MODIFIED:
         if ($is_global) {
           return 'dateModified';
         }
         return 'r.dateModified';
       case self::ORDER_CREATED:
         if ($is_global) {
           return 'id';
         }
         return 'r.id';
       case self::ORDER_PATH_MODIFIED:
         if (!$this->pathIDs) {
           throw new Exception(
             "To use ORDER_PATH_MODIFIED, you must specify withPath().");
         }
         return 'p.epoch';
       default:
         throw new Exception("Unknown query order constant '{$this->order}'.");
     }
   }
 
   private function loadRelationships($conn_r, array $revisions) {
     assert_instances_of($revisions, 'DifferentialRevision');
     $relationships = queryfx_all(
       $conn_r,
       'SELECT * FROM %T WHERE revisionID in (%Ld) ORDER BY sequence',
       DifferentialRevision::RELATIONSHIP_TABLE,
       mpull($revisions, 'getID'));
     $relationships = igroup($relationships, 'revisionID');
     foreach ($revisions as $revision) {
       $revision->attachRelationships(
         idx(
           $relationships,
           $revision->getID(),
           array()));
     }
   }
 
   private function loadCommitPHIDs($conn_r, array $revisions) {
     assert_instances_of($revisions, 'DifferentialRevision');
     $commit_phids = queryfx_all(
       $conn_r,
       'SELECT * FROM %T WHERE revisionID IN (%Ld)',
       DifferentialRevision::TABLE_COMMIT,
       mpull($revisions, 'getID'));
     $commit_phids = igroup($commit_phids, 'revisionID');
     foreach ($revisions as $revision) {
       $phids = idx($commit_phids, $revision->getID(), array());
       $phids = ipull($phids, 'commitPHID');
       $revision->attachCommitPHIDs($phids);
     }
   }
 
   private function loadDiffIDs($conn_r, array $revisions) {
     assert_instances_of($revisions, 'DifferentialRevision');
 
     $diff_table = new DifferentialDiff();
 
     $diff_ids = queryfx_all(
       $conn_r,
       'SELECT revisionID, id FROM %T WHERE revisionID IN (%Ld)
         ORDER BY id DESC',
       $diff_table->getTableName(),
       mpull($revisions, 'getID'));
     $diff_ids = igroup($diff_ids, 'revisionID');
 
     foreach ($revisions as $revision) {
       $ids = idx($diff_ids, $revision->getID(), array());
       $ids = ipull($ids, 'id');
       $revision->attachDiffIDs($ids);
     }
   }
 
   private function loadActiveDiffs($conn_r, array $revisions) {
     assert_instances_of($revisions, 'DifferentialRevision');
 
     $diff_table = new DifferentialDiff();
 
     $load_ids = array();
     foreach ($revisions as $revision) {
       $diffs = $revision->getDiffIDs();
       if ($diffs) {
         $load_ids[] = max($diffs);
       }
     }
 
     $active_diffs = array();
     if ($load_ids) {
       $active_diffs = $diff_table->loadAllWhere(
         'id IN (%Ld)',
         $load_ids);
     }
 
     $active_diffs = mpull($active_diffs, null, 'getRevisionID');
     foreach ($revisions as $revision) {
       $revision->attachActiveDiff(idx($active_diffs, $revision->getID()));
     }
   }
 
   private function loadHashes(
     AphrontDatabaseConnection $conn_r,
     array $revisions) {
     assert_instances_of($revisions, 'DifferentialRevision');
 
     $data = queryfx_all(
       $conn_r,
       'SELECT * FROM %T WHERE revisionID IN (%Ld)',
       'differential_revisionhash',
       mpull($revisions, 'getID'));
 
     $data = igroup($data, 'revisionID');
     foreach ($revisions as $revision) {
       $hashes = idx($data, $revision->getID(), array());
       $list = array();
       foreach ($hashes as $hash) {
         $list[] = array($hash['type'], $hash['hash']);
       }
       $revision->attachHashes($list);
     }
   }
 
   private function loadReviewers(
     AphrontDatabaseConnection $conn_r,
     array $revisions) {
 
     assert_instances_of($revisions, 'DifferentialRevision');
     $edge_type = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;
 
     $edges = id(new PhabricatorEdgeQuery())
       ->withSourcePHIDs(mpull($revisions, 'getPHID'))
       ->withEdgeTypes(array($edge_type))
       ->needEdgeData(true)
       ->execute();
 
     foreach ($revisions as $revision) {
       $revision_edges = $edges[$revision->getPHID()][$edge_type];
 
       $reviewers = array();
       foreach ($revision_edges as $user_phid => $edge) {
         $data = $edge['data'];
         $reviewers[] = new DifferentialReviewer(
           $user_phid,
           idx($data, 'status'),
           idx($data, 'diff'));
       }
 
       $revision->attachReviewerStatus($reviewers);
     }
 
   }
 
 
 
   public static function splitResponsible(array $revisions, array $user_phids) {
     $blocking = array();
     $active = array();
     $waiting = array();
     $status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
 
     // Bucket revisions into $blocking (revisions where you are blocking
     // others), $active (revisions you need to do something about) and $waiting
     // (revisions you're waiting on someone else to do something about).
     foreach ($revisions as $revision) {
       $needs_review = ($revision->getStatus() == $status_review);
       $filter_is_author = in_array($revision->getAuthorPHID(), $user_phids);
       if (!$revision->getReviewers()) {
         $needs_review = false;
       }
 
       // If exactly one of "needs review" and "the user is the author" is
       // true, the user needs to act on it. Otherwise, they're waiting on
       // it.
       if ($needs_review ^ $filter_is_author) {
         if ($needs_review) {
           array_unshift($blocking, $revision);
         } else {
           $active[] = $revision;
         }
       } else {
         $waiting[] = $revision;
       }
     }
 
     return array($blocking, $active, $waiting);
   }
 
 
 }
diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
index ba9e7a0383..2533a3789c 100644
--- a/src/applications/differential/storage/DifferentialRevision.php
+++ b/src/applications/differential/storage/DifferentialRevision.php
@@ -1,377 +1,377 @@
 <?php
 
 final class DifferentialRevision extends DifferentialDAO
   implements
     PhabricatorTokenReceiverInterface,
     PhabricatorPolicyInterface,
     PhrequentTrackableInterface {
 
   protected $title;
   protected $originalTitle;
   protected $status;
 
   protected $summary;
   protected $testPlan;
 
   protected $phid;
   protected $authorPHID;
   protected $lastReviewerPHID;
 
   protected $dateCommitted;
 
   protected $lineCount;
   protected $attached = array();
 
   protected $mailKey;
   protected $branchName;
   protected $arcanistProjectPHID;
   protected $repositoryPHID;
   protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
   protected $editPolicy = PhabricatorPolicies::POLICY_USER;
 
   private $relationships = self::ATTACHABLE;
   private $commits = self::ATTACHABLE;
   private $activeDiff = self::ATTACHABLE;
   private $diffIDs = self::ATTACHABLE;
   private $hashes = self::ATTACHABLE;
   private $repository = self::ATTACHABLE;
 
   private $reviewerStatus = self::ATTACHABLE;
 
   const RELATIONSHIP_TABLE    = 'differential_relationship';
   const TABLE_COMMIT          = 'differential_commit';
 
   const RELATION_REVIEWER     = 'revw';
   const RELATION_SUBSCRIBED   = 'subd';
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'attached'      => self::SERIALIZATION_JSON,
         'unsubscribed'  => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function setTitle($title) {
     $this->title = $title;
     if (!$this->getID()) {
       $this->originalTitle = $title;
     }
     return $this;
   }
 
   public function loadIDsByCommitPHIDs($phids) {
     if (!$phids) {
       return array();
     }
     $revision_ids = queryfx_all(
       $this->establishConnection('r'),
       'SELECT * FROM %T WHERE commitPHID IN (%Ls)',
       self::TABLE_COMMIT,
       $phids);
     return ipull($revision_ids, 'revisionID', 'commitPHID');
   }
 
   public function loadCommitPHIDs() {
     if (!$this->getID()) {
       return ($this->commits = array());
     }
 
     $commits = queryfx_all(
       $this->establishConnection('r'),
       'SELECT commitPHID FROM %T WHERE revisionID = %d',
       self::TABLE_COMMIT,
       $this->getID());
     $commits = ipull($commits, 'commitPHID');
 
     return ($this->commits = $commits);
   }
 
   public function getCommitPHIDs() {
     return $this->assertAttached($this->commits);
   }
 
   public function getActiveDiff() {
     // TODO: Because it's currently technically possible to create a revision
     // without an associated diff, we allow an attached-but-null active diff.
     // It would be good to get rid of this once we make diff-attaching
     // transactional.
 
     return $this->assertAttached($this->activeDiff);
   }
 
   public function attachActiveDiff($diff) {
     $this->activeDiff = $diff;
     return $this;
   }
 
   public function getDiffIDs() {
     return $this->assertAttached($this->diffIDs);
   }
 
   public function attachDiffIDs(array $ids) {
     rsort($ids);
     $this->diffIDs = array_values($ids);
     return $this;
   }
 
   public function attachCommitPHIDs(array $phids) {
     $this->commits = array_values($phids);
     return $this;
   }
 
   public function getAttachedPHIDs($type) {
     return array_keys(idx($this->attached, $type, array()));
   }
 
   public function setAttachedPHIDs($type, array $phids) {
     $this->attached[$type] = array_fill_keys($phids, array());
     return $this;
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       DifferentialPHIDTypeRevision::TYPECONST);
   }
 
   public function loadComments() {
     if (!$this->getID()) {
       return array();
     }
     return id(new DifferentialCommentQuery())
       ->withRevisionIDs(array($this->getID()))
       ->execute();
   }
 
   public function loadActiveDiff() {
     return id(new DifferentialDiff())->loadOneWhere(
       'revisionID = %d ORDER BY id DESC LIMIT 1',
       $this->getID());
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->mailKey = Filesystem::readRandomCharacters(40);
     }
     return parent::save();
   }
 
   public function delete() {
     $this->openTransaction();
     $diffs = id(new DifferentialDiffQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withRevisionIDs(array($this->getID()))
       ->execute();
       foreach ($diffs as $diff) {
         $diff->delete();
       }
 
       $conn_w = $this->establishConnection('w');
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE revisionID = %d',
         self::RELATIONSHIP_TABLE,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE revisionID = %d',
         self::TABLE_COMMIT,
         $this->getID());
 
       $comments = id(new DifferentialCommentQuery())
         ->withRevisionIDs(array($this->getID()))
         ->execute();
       foreach ($comments as $comment) {
         $comment->delete();
       }
 
       $inlines = id(new DifferentialInlineCommentQuery())
         ->withRevisionIDs(array($this->getID()))
         ->execute();
       foreach ($inlines as $inline) {
         $inline->delete();
       }
 
       $fields = id(new DifferentialAuxiliaryField())->loadAllWhere(
         'revisionPHID = %s',
         $this->getPHID());
       foreach ($fields as $field) {
         $field->delete();
       }
 
       // we have to do paths a little differentally as they do not have
       // an id or phid column for delete() to act on
       $dummy_path = new DifferentialAffectedPath();
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE revisionID = %d',
         $dummy_path->getTableName(),
         $this->getID());
 
       $result = parent::delete();
     $this->saveTransaction();
     return $result;
   }
 
   public function loadRelationships() {
     if (!$this->getID()) {
       $this->relationships = array();
       return;
     }
 
     $data = queryfx_all(
       $this->establishConnection('r'),
       'SELECT * FROM %T WHERE revisionID = %d ORDER BY sequence',
       self::RELATIONSHIP_TABLE,
       $this->getID());
     return $this->attachRelationships($data);
   }
 
   public function attachRelationships(array $relationships) {
     $this->relationships = igroup($relationships, 'relation');
     return $this;
   }
 
   public function getReviewers() {
     return $this->getRelatedPHIDs(self::RELATION_REVIEWER);
   }
 
   public function getCCPHIDs() {
     return $this->getRelatedPHIDs(self::RELATION_SUBSCRIBED);
   }
 
   private function getRelatedPHIDs($relation) {
     $this->assertAttached($this->relationships);
 
     return ipull($this->getRawRelations($relation), 'objectPHID');
   }
 
   public function getRawRelations($relation) {
     return idx($this->relationships, $relation, array());
   }
 
   public function loadUnsubscribedPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->phid,
       PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);
   }
 
   public function getPrimaryReviewer() {
     $reviewers = $this->getReviewers();
     $last = $this->lastReviewerPHID;
     if (!$last || !in_array($last, $reviewers)) {
       return head($this->getReviewers());
     }
     return $last;
   }
 
   public function loadReviewedBy() {
     $reviewer = null;
 
     if ($this->status == ArcanistDifferentialRevisionStatus::ACCEPTED ||
         $this->status == ArcanistDifferentialRevisionStatus::CLOSED) {
       $comments = $this->loadComments();
       foreach ($comments as $comment) {
         $action = $comment->getAction();
         if ($action == DifferentialAction::ACTION_ACCEPT) {
           $reviewer = $comment->getAuthorPHID();
         } else if ($action == DifferentialAction::ACTION_REJECT ||
                    $action == DifferentialAction::ACTION_ABANDON ||
                    $action == DifferentialAction::ACTION_RETHINK) {
           $reviewer = null;
         }
       }
     }
 
     return $reviewer;
   }
 
   public function getHashes() {
     return $this->assertAttached($this->hashes);
   }
 
   public function attachHashes(array $hashes) {
     $this->hashes = $hashes;
     return $this;
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
 
     // A revision's author (which effectively means "owner" after we added
     // commandeering) can always view and edit it.
     $author_phid = $this->getAuthorPHID();
     if ($author_phid) {
       if ($user->getPHID() == $author_phid) {
         return true;
       }
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     $description = array(
       pht('The owner of a revision can always view and edit it.'),
     );
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         $description[] = pht(
           "A revision's reviewers can always view it.");
-        if ($this->getRepository()) {
+        if ($this->getRepositoryPHID()) {
           $description[] = pht(
             'This revision belongs to a repository. Other users must be able '.
             'to view the repository in order to view this revision.');
         }
         break;
     }
 
     return $description;
   }
 
   public function getUsersToNotifyOfTokenGiven() {
     return array(
       $this->getAuthorPHID(),
     );
   }
 
   public function getReviewerStatus() {
     return $this->assertAttached($this->reviewerStatus);
   }
 
   public function attachReviewerStatus(array $reviewers) {
     assert_instances_of($reviewers, 'DifferentialReviewer');
 
     $this->reviewerStatus = $reviewers;
     return $this;
   }
 
   public function getRepository() {
     return $this->assertAttached($this->repository);
   }
 
   public function attachRepository(PhabricatorRepository $repository = null) {
     $this->repository = $repository;
     return $this;
   }
 }
diff --git a/src/applications/policy/exception/PhabricatorPolicyException.php b/src/applications/policy/exception/PhabricatorPolicyException.php
index 2e43cc0ed3..89649a3b8c 100644
--- a/src/applications/policy/exception/PhabricatorPolicyException.php
+++ b/src/applications/policy/exception/PhabricatorPolicyException.php
@@ -1,5 +1,16 @@
 <?php
 
 final class PhabricatorPolicyException extends Exception {
 
+  private $moreInfo = array();
+
+  public function setMoreInfo(array $more_info) {
+    $this->moreInfo = $more_info;
+    return $this;
+  }
+
+  public function getMoreInfo() {
+    return $this->moreInfo;
+  }
+
 }
diff --git a/src/applications/policy/filter/PhabricatorPolicyFilter.php b/src/applications/policy/filter/PhabricatorPolicyFilter.php
index ec8b7af87a..b5907e6a7a 100644
--- a/src/applications/policy/filter/PhabricatorPolicyFilter.php
+++ b/src/applications/policy/filter/PhabricatorPolicyFilter.php
@@ -1,294 +1,369 @@
 <?php
 
 final class PhabricatorPolicyFilter {
 
   private $viewer;
   private $objects;
   private $capabilities;
   private $raisePolicyExceptions;
   private $userProjects;
 
   public static function mustRetainCapability(
     PhabricatorUser $user,
     PhabricatorPolicyInterface $object,
     $capability) {
 
     if (!self::hasCapability($user, $object, $capability)) {
       throw new Exception(
         "You can not make that edit, because it would remove your ability ".
         "to '{$capability}' the object.");
     }
   }
 
   public static function requireCapability(
     PhabricatorUser $user,
     PhabricatorPolicyInterface $object,
     $capability) {
     $filter = new PhabricatorPolicyFilter();
     $filter->setViewer($user);
     $filter->requireCapabilities(array($capability));
     $filter->raisePolicyExceptions(true);
     $filter->apply(array($object));
   }
 
   public static function hasCapability(
     PhabricatorUser $user,
     PhabricatorPolicyInterface $object,
     $capability) {
 
     $filter = new PhabricatorPolicyFilter();
     $filter->setViewer($user);
     $filter->requireCapabilities(array($capability));
     $result = $filter->apply(array($object));
 
     return (count($result) == 1);
   }
 
   public function setViewer(PhabricatorUser $user) {
     $this->viewer = $user;
     return $this;
   }
 
   public function requireCapabilities(array $capabilities) {
     $this->capabilities = $capabilities;
     return $this;
   }
 
   public function raisePolicyExceptions($raise) {
     $this->raisePolicyExceptions = $raise;
     return $this;
   }
 
   public function apply(array $objects) {
     assert_instances_of($objects, 'PhabricatorPolicyInterface');
 
     $viewer       = $this->viewer;
     $capabilities = $this->capabilities;
 
     if (!$viewer || !$capabilities) {
       throw new Exception(
         'Call setViewer() and requireCapabilities() before apply()!');
     }
 
     // If the viewer is omnipotent, short circuit all the checks and just
     // return the input unmodified. This is an optimization; we know the
     // result already.
     if ($viewer->isOmnipotent()) {
       return $objects;
     }
 
     $filtered = array();
     $viewer_phid = $viewer->getPHID();
 
     if (empty($this->userProjects[$viewer_phid])) {
       $this->userProjects[$viewer_phid] = array();
     }
 
     $need_projects = array();
     foreach ($objects as $key => $object) {
       $object_capabilities = $object->getCapabilities();
       foreach ($capabilities as $capability) {
         if (!in_array($capability, $object_capabilities)) {
           throw new Exception(
             "Testing for capability '{$capability}' on an object which does ".
             "not have that capability!");
         }
 
         $policy = $object->getPolicy($capability);
         $type = phid_get_type($policy);
         if ($type == PhabricatorProjectPHIDTypeProject::TYPECONST) {
           $need_projects[$policy] = $policy;
         }
       }
     }
 
     // If we need projects, check if any of the projects we need are also the
     // objects we're filtering. Because of how project rules work, this is a
     // common case.
     if ($need_projects) {
       foreach ($objects as $object) {
         if ($object instanceof PhabricatorProject) {
           $project_phid = $object->getPHID();
           if (isset($need_projects[$project_phid])) {
             $is_member = $object->isUserMember($viewer_phid);
             $this->userProjects[$viewer_phid][$project_phid] = $is_member;
             unset($need_projects[$project_phid]);
           }
         }
       }
     }
 
     if ($need_projects) {
       $need_projects = array_unique($need_projects);
 
       // NOTE: We're using the omnipotent user here to avoid a recursive
       // descent into madness. We don't actually need to know if the user can
       // see these projects or not, since: the check is "user is member of
       // project", not "user can see project"; and membership implies
       // visibility anyway. Without this, we may load other projects and
       // re-enter the policy filter and generally create a huge mess.
 
       $projects = id(new PhabricatorProjectQuery())
         ->setViewer(PhabricatorUser::getOmnipotentUser())
         ->withMemberPHIDs(array($viewer->getPHID()))
         ->withPHIDs($need_projects)
         ->execute();
 
       foreach ($projects as $project) {
         $this->userProjects[$viewer_phid][$project->getPHID()] = true;
       }
     }
 
     foreach ($objects as $key => $object) {
       $object_capabilities = $object->getCapabilities();
       foreach ($capabilities as $capability) {
         if (!$this->checkCapability($object, $capability)) {
           // If we're missing any capability, move on to the next object.
           continue 2;
         }
 
         // If we make it here, we have all of the required capabilities.
         $filtered[$key] = $object;
       }
     }
 
     return $filtered;
   }
 
   private function checkCapability(
     PhabricatorPolicyInterface $object,
     $capability) {
 
     $policy = $object->getPolicy($capability);
 
     if (!$policy) {
       // TODO: Formalize this somehow?
       $policy = PhabricatorPolicies::POLICY_USER;
     }
 
     if ($policy == PhabricatorPolicies::POLICY_PUBLIC) {
       // If the object is set to "public" but that policy is disabled for this
       // install, restrict the policy to "user".
       if (!PhabricatorEnv::getEnvConfig('policy.allow-public')) {
         $policy = PhabricatorPolicies::POLICY_USER;
       }
 
       // If the object is set to "public" but the capability is anything other
       // than "view", restrict the policy to "user".
       if ($capability != PhabricatorPolicyCapability::CAN_VIEW) {
         $policy = PhabricatorPolicies::POLICY_USER;
       }
     }
 
     $viewer = $this->viewer;
 
     if ($viewer->isOmnipotent()) {
       return true;
     }
 
     if ($object->hasAutomaticCapability($capability, $viewer)) {
       return true;
     }
 
     switch ($policy) {
       case PhabricatorPolicies::POLICY_PUBLIC:
         return true;
       case PhabricatorPolicies::POLICY_USER:
         if ($viewer->getPHID()) {
           return true;
         } else {
           $this->rejectObject($object, $policy, $capability);
         }
         break;
       case PhabricatorPolicies::POLICY_ADMIN:
         if ($viewer->getIsAdmin()) {
           return true;
         } else {
           $this->rejectObject($object, $policy, $capability);
         }
         break;
       case PhabricatorPolicies::POLICY_NOONE:
         $this->rejectObject($object, $policy, $capability);
         break;
       default:
         $type = phid_get_type($policy);
         if ($type == PhabricatorProjectPHIDTypeProject::TYPECONST) {
           if (!empty($this->userProjects[$viewer->getPHID()][$policy])) {
             return true;
           } else {
             $this->rejectObject($object, $policy, $capability);
           }
         } else if ($type == PhabricatorPeoplePHIDTypeUser::TYPECONST) {
           if ($viewer->getPHID() == $policy) {
             return true;
           } else {
             $this->rejectObject($object, $policy, $capability);
           }
         } else {
           throw new Exception("Object has unknown policy '{$policy}'!");
         }
     }
 
     return false;
   }
 
   private function rejectImpossiblePolicy(
     PhabricatorPolicyInterface $object,
     $policy,
     $capability) {
 
     if (!$this->raisePolicyExceptions) {
       return;
     }
 
     // TODO: clean this up
     $verb = $capability;
 
     throw new PhabricatorPolicyException(
       "This object has an impossible {$verb} policy.");
   }
 
-  private function rejectObject($object, $policy, $capability) {
+  public function rejectObject(
+    PhabricatorPolicyInterface $object,
+    $policy,
+    $capability) {
+
     if (!$this->raisePolicyExceptions) {
       return;
     }
 
-    // TODO: clean this up
-    $verb = $capability;
-
-    $message = "You do not have permission to {$verb} this object.";
+    $more = array();
+    switch ($capability) {
+      case PhabricatorPolicyCapability::CAN_VIEW:
+        $message = pht(
+          'This object exists, but you do not have permission to view it.');
+        break;
+      case PhabricatorPolicyCapability::CAN_EDIT:
+        $message = pht('You do not have permission to edit this object.');
+        break;
+      case PhabricatorPolicyCapability::CAN_JOIN:
+        $message = pht('You do not have permission to join this object.');
+        break;
+    }
 
     switch ($policy) {
       case PhabricatorPolicies::POLICY_PUBLIC:
-        $who = "This is curious, since anyone can {$verb} the object.";
+        // Presumably, this is a bug, so we don't bother specializing the
+        // strings.
+        $more = pht('This object is public.');
         break;
       case PhabricatorPolicies::POLICY_USER:
-        $who = "To {$verb} this object, you must be logged in.";
+        // We always raise this as "log in", so we don't need to specialize.
+        $more = pht('This object is available to logged in users.');
         break;
       case PhabricatorPolicies::POLICY_ADMIN:
-        $who = "To {$verb} this object, you must be an administrator.";
+        switch ($capability) {
+          case PhabricatorPolicyCapability::CAN_VIEW:
+            $more = pht('Administrators can view this object.');
+            break;
+          case PhabricatorPolicyCapability::CAN_EDIT:
+            $more = pht('Administrators can edit this object.');
+            break;
+          case PhabricatorPolicyCapability::CAN_JOIN:
+            $more = pht('Administrators can join this object.');
+            break;
+        }
         break;
       case PhabricatorPolicies::POLICY_NOONE:
-        $who = "No one can {$verb} this object.";
+        switch ($capability) {
+          case PhabricatorPolicyCapability::CAN_VIEW:
+            $more = pht('By default, no one can view this object.');
+            break;
+          case PhabricatorPolicyCapability::CAN_EDIT:
+            $more = pht('By default, no one can edit this object.');
+            break;
+          case PhabricatorPolicyCapability::CAN_JOIN:
+            $more = pht('By default, no one can join this object.');
+            break;
+        }
         break;
       default:
         $handle = id(new PhabricatorHandleQuery())
           ->setViewer($this->viewer)
           ->withPHIDs(array($policy))
           ->executeOne();
 
         $type = phid_get_type($policy);
         if ($type == PhabricatorProjectPHIDTypeProject::TYPECONST) {
-          $who = "To {$verb} this object, you must be a member of project ".
-                 "'".$handle->getFullName()."'.";
+          switch ($capability) {
+            case PhabricatorPolicyCapability::CAN_VIEW:
+              $more = pht(
+                'This object is visible to members of the project "%s".',
+                $handle->getFullName());
+              break;
+            case PhabricatorPolicyCapability::CAN_EDIT:
+              $more = pht(
+                'This object can be edited by members of the project "%s".',
+                $handle->getFullName());
+              break;
+            case PhabricatorPolicyCapability::CAN_JOIN:
+              $more = pht(
+                'This object can be joined by members of the project "%s".',
+                $handle->getFullName());
+              break;
+          }
         } else if ($type == PhabricatorPeoplePHIDTypeUser::TYPECONST) {
-          $who = "Only '".$handle->getFullName()."' can {$verb} this object.";
+          switch ($capability) {
+            case PhabricatorPolicyCapability::CAN_VIEW:
+              $more = pht(
+                '%s can view this object.',
+                $handle->getFullName());
+              break;
+            case PhabricatorPolicyCapability::CAN_EDIT:
+              $more = pht(
+                '%s can edit this object.',
+                $handle->getFullName());
+              break;
+            case PhabricatorPolicyCapability::CAN_JOIN:
+              $more = pht(
+                '%s can join this object.',
+                $handle->getFullName());
+              break;
+          }
+
         } else {
-          $who = "It is unclear who can {$verb} this object.";
+          $who = pht("This object has an unknown policy setting.");
         }
         break;
     }
 
-    throw new PhabricatorPolicyException("{$message} {$who}");
+    $more = array_merge(
+      array($more),
+      array_filter((array)$object->describeAutomaticCapability($capability)));
+
+    $exception = new PhabricatorPolicyException($message);
+    $exception->setMoreInfo($more);
+
+    throw $exception;
   }
 }
diff --git a/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php
index a5e74c6a2b..f985d43e67 100644
--- a/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php
+++ b/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php
@@ -1,401 +1,413 @@
 <?php
 
 /**
  * A @{class:PhabricatorQuery} which filters results according to visibility
  * policies for the querying user. Broadly, this class allows you to implement
  * a query that returns only objects the user is allowed to see.
  *
  *   $results = id(new ExampleQuery())
  *     ->setViewer($user)
  *     ->withConstraint($example)
  *     ->execute();
  *
  * Normally, you should extend @{class:PhabricatorCursorPagedPolicyAwareQuery},
  * not this class. @{class:PhabricatorCursorPagedPolicyAwareQuery} provides a
  * more practical interface for building usable queries against most object
  * types.
  *
  * NOTE: Although this class extends @{class:PhabricatorOffsetPagedQuery},
  * offset paging with policy filtering is not efficient. All results must be
  * loaded into the application and filtered here: skipping `N` rows via offset
  * is an `O(N)` operation with a large constant. Prefer cursor-based paging
  * with @{class:PhabricatorCursorPagedPolicyAwareQuery}, which can filter far
  * more efficiently in MySQL.
  *
  * @task config     Query Configuration
  * @task exec       Executing Queries
  * @task policyimpl Policy Query Implementation
  */
 abstract class PhabricatorPolicyAwareQuery extends PhabricatorOffsetPagedQuery {
 
   private $viewer;
   private $raisePolicyExceptions;
   private $parentQuery;
   private $rawResultLimit;
   private $capabilities;
 
 
 /* -(  Query Configuration  )------------------------------------------------ */
 
 
   /**
    * Set the viewer who is executing the query. Results will be filtered
    * according to the viewer's capabilities. You must set a viewer to execute
    * a policy query.
    *
    * @param PhabricatorUser The viewing user.
    * @return this
    * @task config
    */
   final public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
 
   /**
    * Get the query's viewer.
    *
    * @return PhabricatorUser The viewing user.
    * @task config
    */
   final public function getViewer() {
     return $this->viewer;
   }
 
 
   /**
    * Set the parent query of this query. This is useful for nested queries so
    * that configuration like whether or not to raise policy exceptions is
    * seamlessly passed along to child queries.
    *
    * @return this
    * @task config
    */
   final public function setParentQuery(PhabricatorPolicyAwareQuery $query) {
     $this->parentQuery = $query;
     return $this;
   }
 
 
   /**
    * Get the parent query. See @{method:setParentQuery} for discussion.
    *
    * @return PhabricatorPolicyAwareQuery The parent query.
    * @task config
    */
   final public function getParentQuery() {
     return $this->parentQuery;
   }
 
 
   /**
    * Hook to configure whether this query should raise policy exceptions.
    *
    * @return this
    * @task config
    */
   final public function setRaisePolicyExceptions($bool) {
     $this->raisePolicyExceptions = $bool;
     return $this;
   }
 
 
   /**
    * @return bool
    * @task config
    */
   final public function shouldRaisePolicyExceptions() {
     return (bool) $this->raisePolicyExceptions;
   }
 
 
   /**
    * @task config
    */
   final public function requireCapabilities(array $capabilities) {
     $this->capabilities = $capabilities;
     return $this;
   }
 
 
 /* -(  Query Execution  )---------------------------------------------------- */
 
 
   /**
    * Execute the query, expecting a single result. This method simplifies
    * loading objects for detail pages or edit views.
    *
    *   // Load one result by ID.
    *   $obj = id(new ExampleQuery())
    *     ->setViewer($user)
    *     ->withIDs(array($id))
    *     ->executeOne();
    *   if (!$obj) {
    *     return new Aphront404Response();
    *   }
    *
    * If zero results match the query, this method returns `null`.
    * If one result matches the query, this method returns that result.
    *
    * If two or more results match the query, this method throws an exception.
    * You should use this method only when the query constraints guarantee at
    * most one match (e.g., selecting a specific ID or PHID).
    *
    * If one result matches the query but it is caught by the policy filter (for
    * example, the user is trying to view or edit an object which exists but
    * which they do not have permission to see) a policy exception is thrown.
    *
    * @return mixed Single result, or null.
    * @task exec
    */
   final public function executeOne() {
 
     $this->setRaisePolicyExceptions(true);
     try {
       $results = $this->execute();
     } catch (Exception $ex) {
       $this->setRaisePolicyExceptions(false);
       throw $ex;
     }
 
     if (count($results) > 1) {
       throw new Exception("Expected a single result!");
     }
 
     if (!$results) {
       return null;
     }
 
     return head($results);
   }
 
 
   /**
    * Execute the query, loading all visible results.
    *
    * @return list<PhabricatorPolicyInterface> Result objects.
    * @task exec
    */
   final public function execute() {
     if (!$this->viewer) {
       throw new Exception("Call setViewer() before execute()!");
     }
 
     $parent_query = $this->getParentQuery();
     if ($parent_query) {
       $this->setRaisePolicyExceptions(
         $parent_query->shouldRaisePolicyExceptions());
     }
 
     $results = array();
 
-    $filter = new PhabricatorPolicyFilter();
-    $filter->setViewer($this->viewer);
-
-    if (!$this->capabilities) {
-      $capabilities = array(
-        PhabricatorPolicyCapability::CAN_VIEW,
-      );
-    } else {
-      $capabilities = $this->capabilities;
-    }
-    $filter->requireCapabilities($capabilities);
-    $filter->raisePolicyExceptions($this->shouldRaisePolicyExceptions());
+    $filter = $this->getPolicyFilter();
 
     $offset = (int)$this->getOffset();
     $limit  = (int)$this->getLimit();
     $count  = 0;
 
     if ($limit) {
       $need = $offset + $limit;
     } else {
       $need = 0;
     }
 
     $this->willExecute();
 
     do {
       if ($need) {
         $this->rawResultLimit = min($need - $count, 1024);
       } else {
         $this->rawResultLimit = 0;
       }
 
       try {
         $page = $this->loadPage();
       } catch (PhabricatorEmptyQueryException $ex) {
         $page = array();
       }
 
       if ($page) {
         $maybe_visible = $this->willFilterPage($page);
       } else {
         $maybe_visible = array();
       }
 
       if ($this->shouldDisablePolicyFiltering()) {
         $visible = $maybe_visible;
       } else {
         $visible = $filter->apply($maybe_visible);
       }
 
       $removed = array();
       foreach ($maybe_visible as $key => $object) {
         if (empty($visible[$key])) {
           $removed[$key] = $object;
         }
       }
 
       $this->didFilterResults($removed);
 
       foreach ($visible as $key => $result) {
         ++$count;
 
         // If we have an offset, we just ignore that many results and start
         // storing them only once we've hit the offset. This reduces memory
         // requirements for large offsets, compared to storing them all and
         // slicing them away later.
         if ($count > $offset) {
           $results[$key] = $result;
         }
 
         if ($need && ($count >= $need)) {
           // If we have all the rows we need, break out of the paging query.
           break 2;
         }
       }
 
       if (!$this->rawResultLimit) {
         // If we don't have a load count, we loaded all the results. We do
         // not need to load another page.
         break;
       }
 
       if (count($page) < $this->rawResultLimit) {
         // If we have a load count but the unfiltered results contained fewer
         // objects, we know this was the last page of objects; we do not need
         // to load another page because we can deduce it would be empty.
         break;
       }
 
       $this->nextPage($page);
     } while (true);
 
     $results = $this->didLoadResults($results);
 
     return $results;
   }
 
+  private function getPolicyFilter() {
+    $filter = new PhabricatorPolicyFilter();
+    $filter->setViewer($this->viewer);
+    if (!$this->capabilities) {
+      $capabilities = array(
+        PhabricatorPolicyCapability::CAN_VIEW,
+      );
+    } else {
+      $capabilities = $this->capabilities;
+    }
+    $filter->requireCapabilities($capabilities);
+    $filter->raisePolicyExceptions($this->shouldRaisePolicyExceptions());
+
+    return $filter;
+  }
+
+  protected function didRejectResult(PhabricatorPolicyInterface $object) {
+    $this->getPolicyFilter()->rejectObject(
+      $object,
+      $object->getPolicy(PhabricatorPolicyCapability::CAN_VIEW),
+      PhabricatorPolicyCapability::CAN_VIEW);
+  }
+
 
 /* -(  Policy Query Implementation  )---------------------------------------- */
 
 
   /**
    * Get the number of results @{method:loadPage} should load. If the value is
    * 0, @{method:loadPage} should load all available results.
    *
    * @return int The number of results to load, or 0 for all results.
    * @task policyimpl
    */
   final protected function getRawResultLimit() {
     return $this->rawResultLimit;
   }
 
 
   /**
    * Hook invoked before query execution. Generally, implementations should
    * reset any internal cursors.
    *
    * @return void
    * @task policyimpl
    */
   protected function willExecute() {
     return;
   }
 
 
   /**
    * Load a raw page of results. Generally, implementations should load objects
    * from the database. They should attempt to return the number of results
    * hinted by @{method:getRawResultLimit}.
    *
    * @return list<PhabricatorPolicyInterface> List of filterable policy objects.
    * @task policyimpl
    */
   abstract protected function loadPage();
 
 
   /**
    * Update internal state so that the next call to @{method:loadPage} will
    * return new results. Generally, you should adjust a cursor position based
    * on the provided result page.
    *
    * @param list<PhabricatorPolicyInterface> The current page of results.
    * @return void
    * @task policyimpl
    */
   abstract protected function nextPage(array $page);
 
 
   /**
    * Hook for applying a page filter prior to the privacy filter. This allows
    * you to drop some items from the result set without creating problems with
    * pagination or cursor updates.
    *
    * This method will only be called if data is available. Implementations
    * do not need to handle the case of no results specially.
    *
    * @param   list<wild>  Results from `loadPage()`.
    * @return  list<PhabricatorPolicyInterface> Objects for policy filtering.
    * @task policyimpl
    */
   protected function willFilterPage(array $page) {
     return $page;
   }
 
 
   /**
    * Hook for removing filtered results from alternate result sets. This
    * hook will be called with any objects which were returned by the query but
    * filtered for policy reasons. The query should remove them from any cached
    * or partial result sets.
    *
    * @param list<wild>  List of objects that should not be returned by alternate
    *                    result mechanisms.
    * @return void
    * @task policyimpl
    */
   protected function didFilterResults(array $results) {
     return;
   }
 
 
   /**
    * Hook for applying final adjustments before results are returned. This is
    * used by @{class:PhabricatorCursorPagedPolicyAwareQuery} to reverse results
    * that are queried during reverse paging.
    *
    * @param   list<PhabricatorPolicyInterface> Query results.
    * @return  list<PhabricatorPolicyInterface> Final results.
    * @task policyimpl
    */
   protected function didLoadResults(array $results) {
     return $results;
   }
 
 
   /**
    * Allows a subclass to disable policy filtering. This method is dangerous.
    * It should be used only if the query loads data which has already been
    * filtered (for example, because it wraps some other query which uses
    * normal policy filtering).
    *
    * @return bool True to disable all policy filtering.
    * @task policyimpl
    */
   protected function shouldDisablePolicyFiltering() {
     return false;
   }
 
 }