diff --git a/src/hgdaemon/ArcanistHgServerChannel.php b/src/hgdaemon/ArcanistHgServerChannel.php
index 1850c9af..22f6b4ab 100644
--- a/src/hgdaemon/ArcanistHgServerChannel.php
+++ b/src/hgdaemon/ArcanistHgServerChannel.php
@@ -1,178 +1,179 @@
 <?php
 
 /**
  * Channel to a Mercurial "cmdserver" server. Messages sent to the server
  * look like this:
  *
  *   runcommand\n
  *   8                   # Length, as a 4-byte unsigned long.
  *   log\0
  *   -l\0
  *   5
  *
  * In PHP, the format of these messages is an array of arguments:
  *
  *   array(
  *     'runcommand',
  *     'log',
  *     '-l',
  *     '5',
  *   );
  *
  * The server replies with messages that look like this:
  *
  *   o
  *   1234                # Length, as a 4-byte unsigned long.
  *   <data: 1234 bytes>
  *
  * The first character in a message from the server is the "channel". Mercurial
  * channels have nothing to do with Phutil channels; they are more similar to
  * stdout/stderr. Mercurial has four primary channels:
  *
  *   'o'utput, like stdout
  *   'e'rror, like stderr
  *   'r'esult, like return codes
  *   'd'ebug, like an external log file
  *
  * In PHP, the format of these messages is a pair, with the channel and then
  * the data:
  *
  *   array('o', '<data...>');
  *
  * In general, we send "runcommand" requests, and the server responds with
  * a series of messages on the "output" channel and then a single response
  * on the "result" channel to indicate that output is complete.
  *
  * @task protocol Protocol Implementation
  */
 final class ArcanistHgServerChannel extends PhutilProtocolChannel {
 
   const MODE_CHANNEL = 'channel';
   const MODE_LENGTH  = 'length';
   const MODE_BLOCK   = 'block';
 
   private $mode                   = self::MODE_CHANNEL;
   private $byteLengthOfNextChunk  = 1;
   private $buf                    = '';
+  private $outputChannel;
 
 
 /* -(  Protocol Implementation  )-------------------------------------------- */
 
 
   /**
    * Encode a message for transmission to the server. The message should be
    * formatted as an array, like this:
    *
    *   array(
    *     'runcommand',
    *     'log',
    *     '-l',
    *     '5',
    *   );
    *
    *
    * We will return the cmdserver version of this:
    *
    *   runcommand\n
    *   8                   # Length, as a 4-byte unsigned long.
    *   log\0
    *   -l\0
    *   5
    *
    * @param list<string> List of command arguments.
    * @return string Encoded string for transmission to the server.
    *
    * @task protocol
    */
   protected function encodeMessage($argv) {
     if (!is_array($argv)) {
       throw new Exception(
         pht('Message to Mercurial server should be an array.'));
     }
 
     $command = head($argv);
     $args = array_slice($argv, 1);
 
     $args = implode("\0", $args);
 
     $len = strlen($args);
     $len = pack('N', $len);
 
     return "{$command}\n{$len}{$args}";
   }
 
 
   /**
    * Decode a message received from the server. The message looks like this:
    *
    *   o
    *   1234                # Length, as a 4-byte unsigned long.
    *   <data: 1234 bytes>
    *
    * ...where 'o' is the "channel" the message is being sent over.
    *
    * We decode into a pair in PHP, which looks like this:
    *
    *   array('o', '<data...>');
    *
    * @param string Bytes from the server.
    * @return list<pair<string,string>> Zero or more complete messages.
    *
    * @task protocol
    */
   protected function decodeStream($data) {
     $this->buf .= $data;
 
     // We always know how long the next chunk is, so this parser is fairly
     // easy to implement.
 
     $messages = array();
     while ($this->byteLengthOfNextChunk <= strlen($this->buf)) {
       $chunk = substr($this->buf, 0, $this->byteLengthOfNextChunk);
       $this->buf = substr($this->buf, $this->byteLengthOfNextChunk);
 
       switch ($this->mode) {
         case self::MODE_CHANNEL:
           // We've received the channel name, one of 'o', 'e', 'r' or 'd' for
           // 'output', 'error', 'result' or 'debug' respectively. This is a
           // single byte long. Next, we'll expect a length.
 
-          $this->channel = $chunk;
+          $this->outputChannel = $chunk;
           $this->byteLengthOfNextChunk = 4;
           $this->mode = self::MODE_LENGTH;
           break;
         case self::MODE_LENGTH:
           // We've received the length of the data, as a 4-byte big-endian
           // unsigned integer. Next, we'll expect the data itself.
 
           $this->byteLengthOfNextChunk = head(unpack('N', $chunk));
           $this->mode = self::MODE_BLOCK;
           break;
         case self::MODE_BLOCK:
           // We've received the data itself, which is a block of bytes of the
           // given length. We produce a message from the channel and the data
           // and return it. Next, we expect another channel name.
 
-          $message = array($this->channel, $chunk);
+          $message = array($this->outputChannel, $chunk);
 
           $this->byteLengthOfNextChunk = 1;
           $this->mode = self::MODE_CHANNEL;
-          $this->channel = null;
+          $this->outputChannel = null;
 
           $messages[] = $message;
           break;
       }
     }
 
     // Return zero or more messages, which might look something like this:
     //
     //   array(
     //     array('o', '<...>'),
     //     array('o', '<...>'),
     //     array('r', '<...>'),
     //   );
 
     return $messages;
   }
 
 }
diff --git a/src/land/ArcanistGitLandEngine.php b/src/land/ArcanistGitLandEngine.php
index 12b90548..6b0a38cd 100644
--- a/src/land/ArcanistGitLandEngine.php
+++ b/src/land/ArcanistGitLandEngine.php
@@ -1,595 +1,595 @@
 <?php
 
 final class ArcanistGitLandEngine
   extends ArcanistLandEngine {
 
   private $localRef;
   private $localCommit;
   private $sourceCommit;
   private $mergedRef;
   private $restoreWhenDestroyed;
 
   public function execute() {
     $this->verifySourceAndTargetExist();
     $this->fetchTarget();
 
     $this->printLandingCommits();
 
     if ($this->getShouldPreview()) {
       $this->writeInfo(
         pht('PREVIEW'),
         pht('Completed preview of operation.'));
       return;
     }
 
     $this->saveLocalState();
 
     try {
       $this->identifyRevision();
       $this->updateWorkingCopy();
 
       if ($this->getShouldHold()) {
         $this->didHoldChanges();
       } else {
         $this->pushChange();
         $this->reconcileLocalState();
 
         $api = $this->getRepositoryAPI();
         $api->execxLocal('submodule update --init --recursive');
 
         if ($this->getShouldKeep()) {
           echo tsprintf(
             "%s\n",
             pht('Keeping local branch.'));
         } else {
           $this->destroyLocalBranch();
         }
 
         $this->writeOkay(
           pht('DONE'),
           pht('Landed changes.'));
       }
 
       $this->restoreWhenDestroyed = false;
     } catch (Exception $ex) {
       $this->restoreLocalState();
       throw $ex;
     }
   }
 
   public function __destruct() {
     if ($this->restoreWhenDestroyed) {
-      $this->writeWARN(
+      $this->writeWarn(
         pht('INTERRUPTED!'),
         pht('Restoring working copy to its original state.'));
 
       $this->restoreLocalState();
     }
   }
 
   protected function getLandingCommits() {
     $api = $this->getRepositoryAPI();
 
     list($out) = $api->execxLocal(
       'log --oneline %s..%s --',
       $this->getTargetFullRef(),
       $this->sourceCommit);
 
     $out = trim($out);
 
     if (!strlen($out)) {
       return array();
     } else {
       return phutil_split_lines($out, false);
     }
   }
 
   private function identifyRevision() {
     $api = $this->getRepositoryAPI();
     $api->execxLocal('checkout %s --', $this->getSourceRef());
     call_user_func($this->getBuildMessageCallback(), $this);
   }
 
   private function verifySourceAndTargetExist() {
     $api = $this->getRepositoryAPI();
 
     list($err) = $api->execManualLocal(
       'rev-parse --verify %s',
       $this->getTargetFullRef());
 
     if ($err) {
       throw new Exception(
         pht(
           'Branch "%s" does not exist in remote "%s".',
           $this->getTargetOnto(),
           $this->getTargetRemote()));
     }
 
     list($err, $stdout) = $api->execManualLocal(
       'rev-parse --verify %s',
       $this->getSourceRef());
 
     if ($err) {
       throw new Exception(
         pht(
           'Branch "%s" does not exist in the local working copy.',
           $this->getSourceRef()));
     }
 
     $this->sourceCommit = trim($stdout);
   }
 
   private function fetchTarget() {
     $api = $this->getRepositoryAPI();
 
     $ref = $this->getTargetFullRef();
 
     $this->writeInfo(
       pht('FETCH'),
       pht('Fetching %s...', $ref));
 
     // NOTE: Although this output isn't hugely useful, we need to passthru
     // instead of using a subprocess here because `git fetch` may prompt the
     // user to enter a password if they're fetching over HTTP with basic
     // authentication. See T10314.
 
     $err = $api->execPassthru(
       'fetch --quiet -- %s %s',
       $this->getTargetRemote(),
       $this->getTargetOnto());
 
     if ($err) {
       throw new ArcanistUsageException(
         pht(
           'Fetch failed! Fix the error and run "%s" again.',
           'arc land'));
     }
   }
 
   private function updateWorkingCopy() {
     $api = $this->getRepositoryAPI();
     $source = $this->sourceCommit;
 
     $api->execxLocal(
       'checkout %s --',
       $this->getTargetFullRef());
 
     list($original_author, $original_date) = $this->getAuthorAndDate($source);
 
     try {
       if ($this->getShouldSquash()) {
         // NOTE: We're explicitly specifying "--ff" to override the presence
         // of "merge.ff" options in user configuration.
 
         $api->execxLocal(
           'merge --no-stat --no-commit --ff --squash -- %s',
           $source);
       } else {
         $api->execxLocal(
           'merge --no-stat --no-commit --no-ff -- %s',
           $source);
       }
     } catch (Exception $ex) {
       $api->execManualLocal('merge --abort');
       $api->execManualLocal('reset --hard HEAD --');
 
       throw new Exception(
         pht(
           'Local "%s" does not merge cleanly into "%s". Merge or rebase '.
           'local changes so they can merge cleanly.',
           $this->getSourceRef(),
           $this->getTargetFullRef()));
     }
 
     // TODO: This could probably be cleaner by asking the API a question
     // about working copy status instead of running a raw diff command. See
     // discussion in T11435.
     list($changes) = $api->execxLocal('diff --no-ext-diff HEAD --');
     $changes = trim($changes);
     if (!strlen($changes)) {
       throw new Exception(
         pht(
           'Merging local "%s" into "%s" produces an empty diff. '.
           'This usually means these changes have already landed.',
           $this->getSourceRef(),
           $this->getTargetFullRef()));
     }
 
     $api->execxLocal(
       'commit --author %s --date %s -F %s --',
       $original_author,
       $original_date,
       $this->getCommitMessageFile());
 
     $this->getWorkflow()->didCommitMerge();
 
     list($stdout) = $api->execxLocal(
       'rev-parse --verify %s',
       'HEAD');
     $this->mergedRef = trim($stdout);
   }
 
   private function pushChange() {
     $api = $this->getRepositoryAPI();
 
     $this->writeInfo(
       pht('PUSHING'),
       pht('Pushing changes to "%s".', $this->getTargetFullRef()));
 
     $err = $api->execPassthru(
       'push -- %s %s:%s',
       $this->getTargetRemote(),
       $this->mergedRef,
       $this->getTargetOnto());
 
     if ($err) {
       throw new ArcanistUsageException(
         pht(
           'Push failed! Fix the error and run "%s" again.',
           'arc land'));
     }
   }
 
   private function reconcileLocalState() {
     $api = $this->getRepositoryAPI();
 
     // Try to put the user into the best final state we can. This is very
     // complicated because users are incredibly creative and their local
     // branches may have the same names as branches in the remote but no
     // relationship to them.
 
     if ($this->localRef != $this->getSourceRef()) {
       // The user ran `arc land X` but was on a different branch, so just put
       // them back wherever they were before.
       $this->writeInfo(
         pht('RESTORE'),
         pht('Switching back to "%s".', $this->localRef));
       $this->restoreLocalState();
       return;
     }
 
     // We're going to try to find a path to the upstream target branch. We
     // try in two different ways:
     //
     //   - follow the source branch directly along tracking branches until
     //     we reach the upstream; or
     //   - follow a local branch with the same name as the target branch until
     //     we reach the upstream.
 
     // First, get the path from whatever we landed to wherever it goes.
     $local_branch = $this->getSourceRef();
 
     $path = $api->getPathToUpstream($local_branch);
     if ($path->getLength()) {
       // We may want to discard the thing we landed from the path, if we're
       // going to delete it. In this case, we don't want to update it or worry
       // if it's dirty.
       if ($this->getSourceRef() == $this->getTargetOnto()) {
         // In this case, we've done something like land "master" onto itself,
         // so we do want to update the actual branch. We're going to use the
         // entire path.
       } else {
         // Otherwise, we're going to delete the branch at the end of the
         // workflow, so throw it away the most-local branch that isn't long
         // for this world.
         $path->removeUpstream($local_branch);
 
         if (!$path->getLength()) {
           // The local branch tracked upstream directly; however, it
           // may not be the only one to do so.  If there's a local
           // branch of the same name that tracks the remote, try
           // switching to that.
           $local_branch = $this->getTargetOnto();
           list($err) = $api->execManualLocal(
             'rev-parse --verify %s',
             $local_branch);
           if (!$err) {
             $path = $api->getPathToUpstream($local_branch);
           }
           if (!$path->isConnectedToRemote()) {
             $this->writeInfo(
               pht('UPDATE'),
               pht(
                 'Local branch "%s" directly tracks remote, staying on '.
                 'detached HEAD.',
                 $local_branch));
             return;
           }
         }
 
         $local_branch = head($path->getLocalBranches());
       }
     } else {
       // The source branch has no upstream, so look for a local branch with
       // the same name as the target branch. This corresponds to the common
       // case where you have "master" and checkout local branches from it
       // with "git checkout -b feature", then land onto "master".
 
       $local_branch = $this->getTargetOnto();
 
       list($err) = $api->execManualLocal(
         'rev-parse --verify %s',
         $local_branch);
       if ($err) {
         $this->writeInfo(
           pht('UPDATE'),
           pht(
             'Local branch "%s" does not exist, staying on detached HEAD.',
             $local_branch));
         return;
       }
 
       $path = $api->getPathToUpstream($local_branch);
     }
 
     if ($path->getCycle()) {
       $this->writeWarn(
         pht('LOCAL CYCLE'),
         pht(
           'Local branch "%s" tracks an upstream but following it leads to '.
           'a local cycle, staying on detached HEAD.',
           $local_branch));
       return;
     }
 
     if (!$path->isConnectedToRemote()) {
       $this->writeInfo(
         pht('UPDATE'),
         pht(
           'Local branch "%s" is not connected to a remote, staying on '.
           'detached HEAD.',
           $local_branch));
       return;
     }
 
     $remote_remote = $path->getRemoteRemoteName();
     $remote_branch = $path->getRemoteBranchName();
 
     $remote_actual = $remote_remote.'/'.$remote_branch;
     $remote_expect = $this->getTargetFullRef();
     if ($remote_actual != $remote_expect) {
       $this->writeInfo(
         pht('UPDATE'),
         pht(
           'Local branch "%s" is connected to a remote ("%s") other than '.
           'the target remote ("%s"), staying on detached HEAD.',
           $local_branch,
           $remote_actual,
           $remote_expect));
       return;
     }
 
     // If we get this far, we have a sequence of branches which ultimately
     // connect to the remote. We're going to try to update them all in reverse
     // order, from most-upstream to most-local.
 
     $cascade_branches = $path->getLocalBranches();
     $cascade_branches = array_reverse($cascade_branches);
 
     // First, check if any of them are ahead of the remote.
 
     $ahead_of_remote = array();
     foreach ($cascade_branches as $cascade_branch) {
       list($stdout) = $api->execxLocal(
         'log %s..%s --',
         $this->mergedRef,
         $cascade_branch);
       $stdout = trim($stdout);
 
       if (strlen($stdout)) {
         $ahead_of_remote[$cascade_branch] = $cascade_branch;
       }
     }
 
     // We're going to handle the last branch (the thing we ultimately intend
     // to check out) differently. It's OK if it's ahead of the remote, as long
     // as we just landed it.
 
     $local_ahead = isset($ahead_of_remote[$local_branch]);
     unset($ahead_of_remote[$local_branch]);
     $land_self = ($this->getTargetOnto() === $this->getSourceRef());
 
     // We aren't going to pull anything if anything upstream from us is ahead
     // of the remote, or the local is ahead of the remote and we didn't land
     // it onto itself.
     $skip_pull = ($ahead_of_remote || ($local_ahead && !$land_self));
 
     if ($skip_pull) {
       $this->writeInfo(
         pht('UPDATE'),
         pht(
           'Local "%s" is ahead of remote "%s". Checking out "%s" but '.
           'not pulling changes.',
           nonempty(head($ahead_of_remote), $local_branch),
           $this->getTargetFullRef(),
           $local_branch));
 
       $this->writeInfo(
         pht('CHECKOUT'),
         pht(
           'Checking out "%s".',
           $local_branch));
 
       $api->execxLocal('checkout %s --', $local_branch);
 
       return;
     }
 
     // If nothing upstream from our nearest branch is ahead of the remote,
     // pull it all.
 
     $cascade_targets = array();
     if (!$ahead_of_remote) {
       foreach ($cascade_branches as $cascade_branch) {
         if ($local_ahead && ($local_branch == $cascade_branch)) {
           continue;
         }
         $cascade_targets[] = $cascade_branch;
       }
     }
 
     if ($cascade_targets) {
       $this->writeInfo(
         pht('UPDATE'),
         pht(
           'Local "%s" tracks target remote "%s", checking out and '.
           'pulling changes.',
           $local_branch,
           $this->getTargetFullRef()));
 
       foreach ($cascade_targets as $cascade_branch) {
         $this->writeInfo(
           pht('PULL'),
           pht(
             'Checking out and pulling "%s".',
             $cascade_branch));
 
         $api->execxLocal('checkout %s --', $cascade_branch);
         $api->execxLocal('pull --');
       }
 
       if (!$local_ahead) {
         return;
       }
     }
 
     // In this case, the user did something like land a branch onto itself,
     // and the branch is tracking the correct remote. We're going to discard
     // the local state and reset it to the state we just pushed.
 
     $this->writeInfo(
       pht('RESET'),
       pht(
         'Local "%s" landed into remote "%s", resetting local branch to '.
         'remote state.',
         $this->getTargetOnto(),
         $this->getTargetFullRef()));
 
     $api->execxLocal('checkout %s --', $local_branch);
     $api->execxLocal('reset --hard %s --', $this->getTargetFullRef());
 
     return;
   }
 
   private function destroyLocalBranch() {
     $api = $this->getRepositoryAPI();
 
     if ($this->getSourceRef() == $this->getTargetOnto()) {
       // If we landed a branch into a branch with the same name, so don't
       // destroy it. This prevents us from cleaning up "master" if you're
       // landing master into itself.
       return;
     }
 
     // TODO: Maybe this should also recover the proper upstream?
 
     $recovery_command = csprintf(
       'git checkout -b %R %R',
       $this->getSourceRef(),
       $this->sourceCommit);
 
     echo tsprintf(
       "%s\n",
       pht('Cleaning up branch "%s"...', $this->getSourceRef()));
 
     echo tsprintf(
       "%s\n",
       pht('(Use `%s` if you want it back.)', $recovery_command));
 
     $api->execxLocal('branch -D -- %s', $this->getSourceRef());
   }
 
   /**
    * Save the local working copy state so we can restore it later.
    */
   private function saveLocalState() {
     $api = $this->getRepositoryAPI();
 
     $this->localCommit = $api->getWorkingCopyRevision();
 
     list($ref) = $api->execxLocal('rev-parse --abbrev-ref HEAD');
     $ref = trim($ref);
     if ($ref === 'HEAD') {
       $ref = $this->localCommit;
     }
 
     $this->localRef = $ref;
 
     $this->restoreWhenDestroyed = true;
   }
 
   /**
    * Restore the working copy to the state it was in before we started
    * performing writes.
    */
   private function restoreLocalState() {
     $api = $this->getRepositoryAPI();
 
     $api->execxLocal('checkout %s --', $this->localRef);
     $api->execxLocal('reset --hard %s --', $this->localCommit);
     $api->execxLocal('submodule update --init --recursive');
 
     $this->restoreWhenDestroyed = false;
   }
 
   private function getTargetFullRef() {
     return $this->getTargetRemote().'/'.$this->getTargetOnto();
   }
 
   private function getAuthorAndDate($commit) {
     $api = $this->getRepositoryAPI();
 
     // TODO: This is working around Windows escaping problems, see T8298.
 
     list($info) = $api->execxLocal(
       'log -n1 --format=%C %s --',
       '%aD%n%an%n%ae',
       $commit);
 
     $info = trim($info);
     list($date, $author, $email) = explode("\n", $info, 3);
 
     return array(
       "$author <{$email}>",
       $date,
     );
   }
 
   private function didHoldChanges() {
     $this->writeInfo(
       pht('HOLD'),
       pht(
         'Holding change locally, it has not been pushed.'));
 
     $push_command = csprintf(
       '$ git push -- %R %R:%R',
       $this->getTargetRemote(),
       $this->mergedRef,
       $this->getTargetOnto());
 
     $restore_command = csprintf(
       '$ git checkout %R --',
       $this->localRef);
 
     echo tsprintf(
       "\n%s\n\n".
       "%s\n\n".
       "    %s\n\n".
       "%s\n\n".
       "    %s\n\n".
       "%s\n",
       pht(
         'This local working copy now contains the merged changes in a '.
         'detached state.'),
       pht('You can push the changes manually with this command:'),
       $push_command,
       pht(
         'You can go back to how things were before you ran `arc land` with '.
         'this command:'),
       $restore_command,
       pht(
         'Local branches have not been changed, and are still in exactly the '.
         'same state as before.'));
   }
 
 }
diff --git a/src/lint/linter/ArcanistBaseXHPASTLinter.php b/src/lint/linter/ArcanistBaseXHPASTLinter.php
index 72a9bd7e..f0f44827 100644
--- a/src/lint/linter/ArcanistBaseXHPASTLinter.php
+++ b/src/lint/linter/ArcanistBaseXHPASTLinter.php
@@ -1,246 +1,246 @@
 <?php
 
 /**
  * @task sharing Sharing Parse Trees
  */
 abstract class ArcanistBaseXHPASTLinter extends ArcanistFutureLinter {
 
   private $futures = array();
   private $trees = array();
   private $exceptions = array();
   private $refcount = array();
 
   final public function getCacheVersion() {
     $parts = array();
 
     $parts[] = $this->getVersion();
 
     $version = PhutilXHPASTBinary::getVersion();
     if ($version) {
       $parts[] = $version;
     }
 
     return implode('-', $parts);
   }
 
   final public function raiseLintAtToken(
     XHPASTToken $token,
     $code,
     $desc,
     $replace = null) {
     return $this->raiseLintAtOffset(
       $token->getOffset(),
       $code,
       $desc,
       $token->getValue(),
       $replace);
   }
 
   final public function raiseLintAtNode(
     XHPASTNode $node,
     $code,
     $desc,
     $replace = null) {
     return $this->raiseLintAtOffset(
       $node->getOffset(),
       $code,
       $desc,
       $node->getConcreteString(),
       $replace);
   }
 
   final protected function buildFutures(array $paths) {
     return $this->getXHPASTLinter()->buildSharedFutures($paths);
   }
 
   protected function didResolveLinterFutures(array $futures) {
     $this->getXHPASTLinter()->releaseSharedFutures(array_keys($futures));
   }
 
 
 /* -(  Sharing Parse Trees  )------------------------------------------------ */
 
   /**
    * Get the linter object which is responsible for building parse trees.
    *
    * When the engine specifies that several XHPAST linters should execute,
    * we designate one of them as the one which will actually build parse trees.
    * The other linters share trees, so they don't have to recompute them.
    *
    * Roughly, the first linter to execute elects itself as the builder.
    * Subsequent linters request builds and retrieve results from it.
    *
    * @return ArcanistBaseXHPASTLinter Responsible linter.
    * @task sharing
    */
   final protected function getXHPASTLinter() {
     $resource_key = 'xhpast.linter';
 
     // If we're the first linter to run, share ourselves. Otherwise, grab the
     // previously shared linter.
 
     $engine = $this->getEngine();
     $linter = $engine->getLinterResource($resource_key);
     if (!$linter) {
       $linter = $this;
       $engine->setLinterResource($resource_key, $linter);
     }
 
     $base_class = __CLASS__;
     if (!($linter instanceof $base_class)) {
       throw new Exception(
         pht(
           'Expected resource "%s" to be an instance of "%s"!',
           $resource_key,
           $base_class));
     }
 
     return $linter;
   }
 
   /**
    * Build futures on this linter, for use and to share with other linters.
    *
    * @param list<string> Paths to build futures for.
    * @return list<ExecFuture> Futures.
    * @task sharing
    */
   final protected function buildSharedFutures(array $paths) {
     foreach ($paths as $path) {
       if (!isset($this->futures[$path])) {
         $this->futures[$path] = PhutilXHPASTBinary::getParserFuture(
           $this->getData($path));
         $this->refcount[$path] = 1;
       } else {
         $this->refcount[$path]++;
       }
     }
     return array_select_keys($this->futures, $paths);
   }
 
 
   /**
    * Release futures on this linter which are no longer in use elsewhere.
    *
    * @param list<string> Paths to release futures for.
    * @return void
    * @task sharing
    */
   final protected function releaseSharedFutures(array $paths) {
     foreach ($paths as $path) {
       if (empty($this->refcount[$path])) {
         throw new Exception(
           pht(
             'Imbalanced calls to shared futures: each call to '.
             '%s for a path must be paired with a call to %s.',
             'buildSharedFutures()',
             'releaseSharedFutures()'));
       }
 
       $this->refcount[$path]--;
 
       if (!$this->refcount[$path]) {
         unset($this->refcount[$path]);
         unset($this->futures[$path]);
         unset($this->trees[$path]);
         unset($this->exceptions[$path]);
       }
     }
   }
 
 
   /**
    * Get a path's tree from the responsible linter.
    *
    * @param   string           Path to retrieve tree for.
    * @return  XHPASTTree|null  Tree, or null if unparseable.
    * @task sharing
    */
   final protected function getXHPASTTreeForPath($path) {
     // If we aren't the linter responsible for actually building the parse
     // trees, go get the tree from that linter.
     if ($this->getXHPASTLinter() !== $this) {
       return $this->getXHPASTLinter()->getXHPASTTreeForPath($path);
     }
 
     if (!array_key_exists($path, $this->trees)) {
       if (!array_key_exists($path, $this->futures)) {
         return;
       }
 
       $this->trees[$path] = null;
 
       try {
         $this->trees[$path] = XHPASTTree::newFromDataAndResolvedExecFuture(
           $this->getData($path),
           $this->futures[$path]->resolve());
         $root = $this->trees[$path]->getRootNode();
         $root->buildSelectCache();
         $root->buildTokenCache();
       } catch (Exception $ex) {
         $this->exceptions[$path] = $ex;
       }
     }
 
     return $this->trees[$path];
   }
 
   /**
    * Get a path's parse exception from the responsible linter.
    *
    * @param   string          Path to retrieve exception for.
-   * @return  Exeption|null   Parse exception, if available.
+   * @return  Exception|null  Parse exception, if available.
    * @task sharing
    */
   final protected function getXHPASTExceptionForPath($path) {
     if ($this->getXHPASTLinter() !== $this) {
       return $this->getXHPASTLinter()->getXHPASTExceptionForPath($path);
     }
 
     return idx($this->exceptions, $path);
   }
 
 
 /* -(  Deprecated  )--------------------------------------------------------- */
 
   /**
    * Retrieve all calls to some specified function(s).
    *
    * Returns all descendant nodes which represent a function call to one of the
    * specified functions.
    *
    * @param  XHPASTNode    Root node.
    * @param  list<string>  Function names.
    * @return AASTNodeList
    */
   protected function getFunctionCalls(XHPASTNode $root, array $function_names) {
     $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
     $nodes = array();
 
     foreach ($calls as $call) {
       $node = $call->getChildByIndex(0);
       $name = strtolower($node->getConcreteString());
 
       if (in_array($name, $function_names)) {
         $nodes[] = $call;
       }
     }
 
     return AASTNodeList::newFromTreeAndNodes($root->getTree(), $nodes);
   }
 
   public function getSuperGlobalNames() {
     return array(
       '$GLOBALS',
       '$_SERVER',
       '$_GET',
       '$_POST',
       '$_FILES',
       '$_COOKIE',
       '$_SESSION',
       '$_REQUEST',
       '$_ENV',
     );
   }
 
 }
diff --git a/src/lint/linter/__tests__/ArcanistClosureLinterTestCase.php b/src/lint/linter/__tests__/ArcanistClosureLinterTestCase.php
index 50c01ca5..f02dc21b 100644
--- a/src/lint/linter/__tests__/ArcanistClosureLinterTestCase.php
+++ b/src/lint/linter/__tests__/ArcanistClosureLinterTestCase.php
@@ -1,13 +1,16 @@
 <?php
 
 final class ArcanistClosureLinterTestCase
   extends ArcanistExternalLinterTestCase {
 
-  public function testLinter() {
+  protected function getLinter() {
     $linter = new ArcanistClosureLinter();
     $linter->setFlags(array('--additional_extensions=lint-test'));
+    return $linter;
+  }
 
-    $this->executeTestsInDirectory(dirname(__FILE__).'/gjslint/', $linter);
+  public function testLinter() {
+    $this->executeTestsInDirectory(dirname(__FILE__).'/gjslint/');
   }
 
 }
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index abe0a220..8efe1bce 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,1471 +1,1474 @@
 <?php
 
 /**
  * Interfaces with Git working copies.
  */
 final class ArcanistGitAPI extends ArcanistRepositoryAPI {
 
   private $repositoryHasNoCommits = false;
   const SEARCH_LENGTH_FOR_PARENT_REVISIONS = 16;
 
   /**
    * For the repository's initial commit, 'git diff HEAD^' and similar do
    * not work. Using this instead does work; it is the hash of the empty tree.
    */
   const GIT_MAGIC_ROOT_COMMIT = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 
   private $symbolicHeadCommit;
   private $resolvedHeadCommit;
 
   protected function buildLocalFuture(array $argv) {
     $argv[0] = 'git '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   public function execPassthru($pattern /* , ... */) {
     $args = func_get_args();
 
     static $git = null;
     if ($git === null) {
       if (phutil_is_windows()) {
         // NOTE: On Windows, phutil_passthru() uses 'bypass_shell' because
         // everything goes to hell if we don't. We must provide an absolute
         // path to Git for this to work properly.
         $git = Filesystem::resolveBinary('git');
         $git = csprintf('%s', $git);
       } else {
         $git = 'git';
       }
     }
 
     $args[0] = $git.' '.$args[0];
 
     return call_user_func_array('phutil_passthru', $args);
   }
 
 
   public function getSourceControlSystemName() {
     return 'git';
   }
 
   public function getGitVersion() {
     list($stdout) = $this->execxLocal('--version');
     return rtrim(str_replace('git version ', '', $stdout));
   }
 
   public function getMetadataPath() {
     static $path = null;
     if ($path === null) {
       list($stdout) = $this->execxLocal('rev-parse --git-dir');
       $path = rtrim($stdout, "\n");
       // the output of git rev-parse --git-dir is an absolute path, unless
       // the cwd is the root of the repository, in which case it uses the
       // relative path of .git. If we get this relative path, turn it into
       // an absolute path.
       if ($path === '.git') {
         $path = $this->getPath('.git');
       }
     }
     return $path;
   }
 
   public function getHasCommits() {
     return !$this->repositoryHasNoCommits;
   }
 
   /**
    * Tests if a child commit is descendant of a parent commit.
    * If child and parent are the same, it returns false.
    * @param Child commit SHA.
    * @param Parent commit SHA.
    * @return bool True if the child is a descendant of the parent.
    */
   private function isDescendant($child, $parent) {
     list($common_ancestor) = $this->execxLocal(
       'merge-base %s %s',
       $child,
       $parent);
     $common_ancestor = trim($common_ancestor);
 
     return ($common_ancestor == $parent) && ($common_ancestor != $child);
   }
 
   public function getLocalCommitInformation() {
     if ($this->repositoryHasNoCommits) {
       // Zero commits.
       throw new Exception(
         pht(
           "You can't get local commit information for a repository with no ".
           "commits."));
     } else if ($this->getBaseCommit() == self::GIT_MAGIC_ROOT_COMMIT) {
       // One commit.
       $against = 'HEAD';
     } else {
 
       // 2..N commits. We include commits reachable from HEAD which are
       // not reachable from the base commit; this is consistent with user
       // expectations even though it is not actually the diff range.
       // Particularly:
       //
       //    |
       //    D <----- master branch
       //    |
       //    C  Y <- feature branch
       //    | /|
       //    B  X
       //    | /
       //    A
       //    |
       //
       // If "A, B, C, D" are master, and the user is at Y, when they run
       // "arc diff B" they want (and get) a diff of B vs Y, but they think about
       // this as being the commits X and Y. If we log "B..Y", we only show
       // Y. With "Y --not B", we show X and Y.
 
 
       if ($this->symbolicHeadCommit !== null) {
         $base_commit = $this->getBaseCommit();
         $resolved_base = $this->resolveCommit($base_commit);
 
         $head_commit = $this->symbolicHeadCommit;
         $resolved_head = $this->getHeadCommit();
 
         if (!$this->isDescendant($resolved_head, $resolved_base)) {
           // NOTE: Since the base commit will have been resolved as the
           // merge-base of the specified base and the specified HEAD, we can't
           // easily tell exactly what's wrong with the range.
 
           // For example, `arc diff HEAD --head HEAD^^^` is invalid because it
           // is reversed, but resolving the commit "HEAD" will compute its
           // merge-base with "HEAD^^^", which is "HEAD^^^", so the range will
           // appear empty.
 
           throw new ArcanistUsageException(
             pht(
               'The specified commit range is empty, backward or invalid: the '.
               'base (%s) is not an ancestor of the head (%s). You can not '.
               'diff an empty or reversed commit range.',
               $base_commit,
               $head_commit));
         }
       }
 
       $against = csprintf(
         '%s --not %s',
         $this->getHeadCommit(),
         $this->getBaseCommit());
     }
 
     // NOTE: Windows escaping of "%" symbols apparently is inherently broken;
     // when passed through escapeshellarg() they are replaced with spaces.
 
     // TODO: Learn how cmd.exe works and find some clever workaround?
 
     // NOTE: If we use "%x00", output is truncated in Windows.
 
     list($info) = $this->execxLocal(
       phutil_is_windows()
         ? 'log %C --format=%C --'
         : 'log %C --format=%s --',
       $against,
       // NOTE: "%B" is somewhat new, use "%s%n%n%b" instead.
       '%H%x01%T%x01%P%x01%at%x01%an%x01%aE%x01%s%x01%s%n%n%b%x02');
 
     $commits = array();
 
     $info = trim($info, " \n\2");
     if (!strlen($info)) {
       return array();
     }
 
     $info = explode("\2", $info);
     foreach ($info as $line) {
       list($commit, $tree, $parents, $time, $author, $author_email,
         $title, $message) = explode("\1", trim($line), 8);
       $message = rtrim($message);
 
       $commits[$commit] = array(
         'commit'  => $commit,
         'tree'    => $tree,
         'parents' => array_filter(explode(' ', $parents)),
         'time'    => $time,
         'author'  => $author,
         'summary' => $title,
         'message' => $message,
         'authorEmail' => $author_email,
       );
     }
 
     return $commits;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     if ($symbolic_commit !== null) {
       if ($symbolic_commit == self::GIT_MAGIC_ROOT_COMMIT) {
         $this->setBaseCommitExplanation(
           pht('you explicitly specified the empty tree.'));
         return $symbolic_commit;
       }
 
       list($err, $merge_base) = $this->execManualLocal(
         'merge-base %s %s',
         $symbolic_commit,
         $this->getHeadCommit());
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             "Unable to find any git commit named '%s' in this repository.",
             $symbolic_commit));
       }
 
       if ($this->symbolicHeadCommit === null) {
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of the explicitly specified base commit ".
             "'%s' and HEAD.",
             $symbolic_commit));
       } else {
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of the explicitly specified base commit ".
             "'%s' and the explicitly specified head commit '%s'.",
             $symbolic_commit,
             $this->symbolicHeadCommit));
       }
 
       return trim($merge_base);
     }
 
     // Detect zero-commit or one-commit repositories. There is only one
     // relative-commit value that makes any sense in these repositories: the
     // empty tree.
     list($err) = $this->execManualLocal('rev-parse --verify HEAD^');
     if ($err) {
       list($err) = $this->execManualLocal('rev-parse --verify HEAD');
       if ($err) {
         $this->repositoryHasNoCommits = true;
       }
 
       if ($this->repositoryHasNoCommits) {
         $this->setBaseCommitExplanation(pht('the repository has no commits.'));
       } else {
         $this->setBaseCommitExplanation(
           pht('the repository has only one commit.'));
       }
 
       return self::GIT_MAGIC_ROOT_COMMIT;
     }
 
     if ($this->getBaseCommitArgumentRules() ||
         $this->getConfigurationManager()->getConfigFromAnySource('base')) {
       $base = $this->resolveBaseCommit();
       if (!$base) {
         throw new ArcanistUsageException(
           pht(
             "None of the rules in your 'base' configuration matched a valid ".
             "commit. Adjust rules or specify which commit you want to use ".
             "explicitly."));
       }
       return $base;
     }
 
     $do_write = false;
     $default_relative = null;
     $working_copy = $this->getWorkingCopyIdentity();
     if ($working_copy) {
       $default_relative = $working_copy->getProjectConfig(
         'git.default-relative-commit');
       $this->setBaseCommitExplanation(
         pht(
           "it is the merge-base of '%s' and HEAD, as specified in '%s' in ".
           "'%s'. This setting overrides other settings.",
           $default_relative,
           'git.default-relative-commit',
           '.arcconfig'));
     }
 
     if (!$default_relative) {
       list($err, $upstream) = $this->execManualLocal(
         'rev-parse --abbrev-ref --symbolic-full-name %s',
         '@{upstream}');
 
       if (!$err) {
         $default_relative = trim($upstream);
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of '%s' (the Git upstream ".
             "of the current branch) HEAD.",
             $default_relative));
       }
     }
 
     if (!$default_relative) {
       $default_relative = $this->readScratchFile('default-relative-commit');
       $default_relative = trim($default_relative);
       if ($default_relative) {
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of '%s' and HEAD, as specified in '%s'.",
             $default_relative,
             '.git/arc/default-relative-commit'));
       }
     }
 
     if (!$default_relative) {
 
       // TODO: Remove the history lesson soon.
 
       echo phutil_console_format(
         "<bg:green>** %s **</bg>\n\n",
         pht('Select a Default Commit Range'));
       echo phutil_console_wrap(
         pht(
           "You're running a command which operates on a range of revisions ".
           "(usually, from some revision to HEAD) but have not specified the ".
           "revision that should determine the start of the range.\n\n".
           "Previously, arc assumed you meant '%s' when you did not specify ".
           "a start revision, but this behavior does not make much sense in ".
           "most workflows outside of Facebook's historic %s workflow.\n\n".
           "arc no longer assumes '%s'. You must specify a relative commit ".
           "explicitly when you invoke a command (e.g., `%s`, not just `%s`) ".
           "or select a default for this working copy.\n\nIn most cases, the ".
           "best default is '%s'. You can also select '%s' to preserve the ".
           "old behavior, or some other remote or branch. But you almost ".
           "certainly want to select 'origin/master'.\n\n".
           "(Technically: the merge-base of the selected revision and HEAD is ".
           "used to determine the start of the commit range.)",
           'HEAD^',
           'git-svn',
           'HEAD^',
           'arc diff HEAD^',
           'arc diff',
           'origin/master',
           'HEAD^'));
 
       $prompt = pht('What default do you want to use? [origin/master]');
       $default = phutil_console_prompt($prompt);
 
       if (!strlen(trim($default))) {
         $default = 'origin/master';
       }
 
       $default_relative = $default;
       $do_write = true;
     }
 
     list($object_type) = $this->execxLocal(
       'cat-file -t %s',
       $default_relative);
 
     if (trim($object_type) !== 'commit') {
       throw new Exception(
         pht(
           "Relative commit '%s' is not the name of a commit!",
           $default_relative));
     }
 
     if ($do_write) {
       // Don't perform this write until we've verified that the object is a
       // valid commit name.
       $this->writeScratchFile('default-relative-commit', $default_relative);
       $this->setBaseCommitExplanation(
         pht(
           "it is the merge-base of '%s' and HEAD, as you just specified.",
           $default_relative));
     }
 
     list($merge_base) = $this->execxLocal(
       'merge-base %s HEAD',
       $default_relative);
 
     return trim($merge_base);
   }
 
   public function getHeadCommit() {
     if ($this->resolvedHeadCommit === null) {
       $this->resolvedHeadCommit = $this->resolveCommit(
         coalesce($this->symbolicHeadCommit, 'HEAD'));
     }
 
     return $this->resolvedHeadCommit;
   }
 
   public function setHeadCommit($symbolic_commit) {
     $this->symbolicHeadCommit = $symbolic_commit;
     $this->reloadCommitRange();
     return $this;
   }
 
   /**
    * Translates a symbolic commit (like "HEAD^") to a commit identifier.
    * @param string_symbol commit.
    * @return string the commit SHA.
    */
   private function resolveCommit($symbolic_commit) {
     list($err, $commit_hash) = $this->execManualLocal(
       'rev-parse %s',
       $symbolic_commit);
 
     if ($err) {
       throw new ArcanistUsageException(
         pht(
           "Unable to find any git commit named '%s' in this repository.",
           $symbolic_commit));
     }
 
     return trim($commit_hash);
   }
 
   private function getDiffFullOptions($detect_moves_and_renames = true) {
     $options = array(
       self::getDiffBaseOptions(),
       '--no-color',
       '--src-prefix=a/',
       '--dst-prefix=b/',
       '-U'.$this->getDiffLinesOfContext(),
     );
 
     if ($detect_moves_and_renames) {
       $options[] = '-M';
       $options[] = '-C';
     }
 
     return implode(' ', $options);
   }
 
   private function getDiffBaseOptions() {
     $options = array(
       // Disable external diff drivers, like graphical differs, since Arcanist
       // needs to capture the diff text.
       '--no-ext-diff',
       // Disable textconv so we treat binary files as binary, even if they have
       // an alternative textual representation. TODO: Ideally, Differential
       // would ship up the binaries for 'arc patch' but display the textconv
       // output in the visual diff.
       '--no-textconv',
+      // Provide a standard view of submodule changes; the 'log' and 'diff'
+      // values do not parse by the diff parser.
+      '--submodule=short',
     );
     return implode(' ', $options);
   }
 
   /**
    * @param the base revision
    * @param head revision. If this is null, the generated diff will include the
    * working copy
    */
   public function getFullGitDiff($base, $head = null) {
     $options = $this->getDiffFullOptions();
 
     if ($head !== null) {
       list($stdout) = $this->execxLocal(
         "diff {$options} %s %s --",
         $base,
         $head);
     } else {
       list($stdout) = $this->execxLocal(
         "diff {$options} %s --",
         $base);
     }
 
     return $stdout;
   }
 
   /**
    * @param string Path to generate a diff for.
    * @param bool   If true, detect moves and renames. Otherwise, ignore
    *               moves/renames; this is useful because it prompts git to
    *               generate real diff text.
    */
   public function getRawDiffText($path, $detect_moves_and_renames = true) {
     $options = $this->getDiffFullOptions($detect_moves_and_renames);
     list($stdout) = $this->execxLocal(
       "diff {$options} %s -- %s",
       $this->getBaseCommit(),
       $path);
     return $stdout;
   }
 
   private function getBranchNameFromRef($ref) {
     $count = 0;
     $branch = preg_replace('/^refs\/heads\//', '', $ref, 1, $count);
     if ($count !== 1) {
       return null;
     }
 
     return $branch;
   }
 
   public function getBranchName() {
     list($err, $stdout, $stderr) = $this->execManualLocal(
       'symbolic-ref --quiet HEAD');
 
     if ($err === 0) {
       // We expect the branch name to come qualified with a refs/heads/ prefix.
       // Verify this, and strip it.
       $ref = rtrim($stdout);
       $branch = $this->getBranchNameFromRef($ref);
       if (!$branch) {
         throw new Exception(
           pht('Failed to parse %s output!', 'git symbolic-ref'));
       }
       return $branch;
     } else if ($err === 1) {
       // Exit status 1 with --quiet indicates that HEAD is detached.
       return null;
     } else {
       throw new Exception(
         pht('Command %s failed: %s', 'git symbolic-ref', $stderr));
     }
   }
 
   public function getRemoteURI() {
     // Determine which remote to examine; default to 'origin'
     $remote = 'origin';
     $branch = $this->getBranchName();
     if ($branch) {
       $path = $this->getPathToUpstream($branch);
       if ($path->isConnectedToRemote()) {
         $remote = $path->getRemoteRemoteName();
       }
     }
 
     // "git ls-remote --get-url" is the appropriate plumbing to get the remote
     // URI. "git config remote.origin.url", on the other hand, may not be as
     // accurate (for example, it does not take into account possible URL
     // rewriting rules set by the user through "url.<base>.insteadOf"). However,
     // the --get-url flag requires git 1.7.5.
     $version = $this->getGitVersion();
     if (version_compare($version, '1.7.5', '>=')) {
       list($stdout) = $this->execxLocal('ls-remote --get-url %s', $remote);
     } else {
       list($stdout) = $this->execxLocal('config %s', "remote.{$remote}.url");
     }
 
     $uri = rtrim($stdout);
     // ls-remote echos the remote name (ie 'origin') if no remote URI is found
     // TODO: In 2.7.0 (circa 2016) git introduced `git remote get-url`
     // with saner error handling.
     if (!$uri || $uri === $remote) {
       return null;
     }
 
     return $uri;
   }
 
   public function getSourceControlPath() {
     // TODO: Try to get something useful here.
     return null;
   }
 
   public function getGitCommitLog() {
     $relative = $this->getBaseCommit();
     if ($this->repositoryHasNoCommits) {
       // No commits yet.
       return '';
     } else if ($relative == self::GIT_MAGIC_ROOT_COMMIT) {
       // First commit.
       list($stdout) = $this->execxLocal(
         'log --format=medium HEAD');
     } else {
       // 2..N commits.
       list($stdout) = $this->execxLocal(
         'log --first-parent --format=medium %s..%s',
         $this->getBaseCommit(),
         $this->getHeadCommit());
     }
     return $stdout;
   }
 
   public function getGitHistoryLog() {
     list($stdout) = $this->execxLocal(
       'log --format=medium -n%d %s',
       self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
       $this->getBaseCommit());
     return $stdout;
   }
 
   public function getSourceControlBaseRevision() {
     list($stdout) = $this->execxLocal(
       'rev-parse %s',
       $this->getBaseCommit());
     return rtrim($stdout, "\n");
   }
 
   public function getCanonicalRevisionName($string) {
     $match = null;
     if (preg_match('/@([0-9]+)$/', $string, $match)) {
       $stdout = $this->getHashFromFromSVNRevisionNumber($match[1]);
     } else {
       list($stdout) = $this->execxLocal(
         phutil_is_windows()
         ? 'show -s --format=%C %s --'
         : 'show -s --format=%s %s --',
         '%H',
         $string);
     }
     return rtrim($stdout);
   }
 
   private function executeSVNFindRev($input, $vcs) {
     $match = array();
     list($stdout) = $this->execxLocal(
       'svn find-rev %s',
       $input);
     if (!$stdout) {
       throw new ArcanistUsageException(
         pht(
           'Cannot find the %s equivalent of %s.',
           $vcs,
           $input));
     }
     // When git performs a partial-rebuild during svn
     // look-up, we need to parse the final line
     $lines = explode("\n", $stdout);
     $stdout = $lines[count($lines) - 2];
     return rtrim($stdout);
   }
 
   // Convert svn revision number to git hash
   public function getHashFromFromSVNRevisionNumber($revision_id) {
     return $this->executeSVNFindRev('r'.$revision_id, 'Git');
   }
 
 
   // Convert a git hash to svn revision number
   public function getSVNRevisionNumberFromHash($hash) {
     return $this->executeSVNFindRev($hash, 'SVN');
   }
 
 
   protected function buildUncommittedStatus() {
     $diff_options = $this->getDiffBaseOptions();
 
     if ($this->repositoryHasNoCommits) {
       $diff_base = self::GIT_MAGIC_ROOT_COMMIT;
     } else {
       $diff_base = 'HEAD';
     }
 
     // Find uncommitted changes.
     $uncommitted_future = $this->buildLocalFuture(
       array(
         'diff %C --raw %s --',
         $diff_options,
         $diff_base,
       ));
 
     $untracked_future = $this->buildLocalFuture(
       array(
         'ls-files --others --exclude-standard',
       ));
 
     // Unstaged changes
     $unstaged_future = $this->buildLocalFuture(
       array(
         'diff-files --name-only',
       ));
 
     $futures = array(
       $uncommitted_future,
       $untracked_future,
       // NOTE: `git diff-files` races with each of these other commands
       // internally, and resolves with inconsistent results if executed
       // in parallel. To work around this, DO NOT run it at the same time.
       // After the other commands exit, we can start the `diff-files` command.
     );
 
     id(new FutureIterator($futures))->resolveAll();
 
     // We're clear to start the `git diff-files` now.
     $unstaged_future->start();
 
     $result = new PhutilArrayWithDefaultValue();
 
     list($stdout) = $uncommitted_future->resolvex();
     $uncommitted_files = $this->parseGitRawDiff($stdout);
     foreach ($uncommitted_files as $path => $mask) {
       $result[$path] |= ($mask | self::FLAG_UNCOMMITTED);
     }
 
     list($stdout) = $untracked_future->resolvex();
     $stdout = rtrim($stdout, "\n");
     if (strlen($stdout)) {
       $stdout = explode("\n", $stdout);
       foreach ($stdout as $path) {
         $result[$path] |= self::FLAG_UNTRACKED;
       }
     }
 
     list($stdout, $stderr) = $unstaged_future->resolvex();
     $stdout = rtrim($stdout, "\n");
     if (strlen($stdout)) {
       $stdout = explode("\n", $stdout);
       foreach ($stdout as $path) {
         $result[$path] |= self::FLAG_UNSTAGED;
       }
     }
 
     return $result->toArray();
   }
 
   protected function buildCommitRangeStatus() {
     list($stdout, $stderr) = $this->execxLocal(
       'diff %C --raw %s --',
       $this->getDiffBaseOptions(),
       $this->getBaseCommit());
 
     return $this->parseGitRawDiff($stdout);
   }
 
   public function getGitConfig($key, $default = null) {
     list($err, $stdout) = $this->execManualLocal('config %s', $key);
     if ($err) {
       return $default;
     }
     return rtrim($stdout);
   }
 
   public function getAuthor() {
     list($stdout) = $this->execxLocal('var GIT_AUTHOR_IDENT');
     return preg_replace('/\s+<.*/', '', rtrim($stdout, "\n"));
   }
 
   public function addToCommit(array $paths) {
     $this->execxLocal(
       'add -A -- %Ls',
       $paths);
     $this->reloadWorkingCopy();
     return $this;
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
 
     // NOTE: "--allow-empty-message" was introduced some time after 1.7.0.4,
     // so we do not provide it and thus require a message.
 
     $this->execxLocal(
       'commit -F %s',
       $tmp_file);
 
     $this->reloadWorkingCopy();
 
     return $this;
   }
 
   public function amendCommit($message = null) {
     if ($message === null) {
       $this->execxLocal('commit --amend --allow-empty -C HEAD');
     } else {
       $tmp_file = new TempFile();
       Filesystem::writeFile($tmp_file, $message);
       $this->execxLocal(
         'commit --amend --allow-empty -F %s',
         $tmp_file);
     }
 
     $this->reloadWorkingCopy();
     return $this;
   }
 
   private function parseGitRawDiff($status, $full = false) {
     static $flags = array(
       'A' => self::FLAG_ADDED,
       'M' => self::FLAG_MODIFIED,
       'D' => self::FLAG_DELETED,
     );
 
     $status = trim($status);
     $lines = array();
     foreach (explode("\n", $status) as $line) {
       if ($line) {
         $lines[] = preg_split("/[ \t]/", $line, 6);
       }
     }
 
     $files = array();
     foreach ($lines as $line) {
       $mask = 0;
 
       // "git diff --raw" lines begin with a ":" character.
       $old_mode = ltrim($line[0], ':');
       $new_mode = $line[1];
 
       // The hashes may be padded with "." characters for alignment. Discard
       // them.
       $old_hash = rtrim($line[2], '.');
       $new_hash = rtrim($line[3], '.');
 
       $flag = $line[4];
       $file = $line[5];
 
       $new_value = intval($new_mode, 8);
       $is_submodule = (($new_value & 0160000) === 0160000);
 
       if (($is_submodule) &&
           ($flag == 'M') &&
           ($old_hash === $new_hash) &&
           ($old_mode === $new_mode)) {
         // See T9455. We see this submodule as "modified", but the old and new
         // hashes are the same and the old and new modes are the same, so we
         // don't directly see a modification.
 
         // We can end up here if we have a submodule which has uncommitted
         // changes inside of it (for example, the user has added untracked
         // files or made uncommitted changes to files in the submodule). In
         // this case, we set a different flag because we can't meaningfully
         // give users the same prompt.
 
         // Note that if the submodule has real changes from the parent
         // perspective (the base commit has changed) and also has uncommitted
         // changes, we'll only see the real changes and miss the uncommitted
         // changes. At the time of writing, there is no reasonable porcelain
         // for finding those changes, and the impact of this error seems small.
 
         $mask |= self::FLAG_EXTERNALS;
       } else if (isset($flags[$flag])) {
         $mask |= $flags[$flag];
       } else if ($flag[0] == 'R') {
         $both = explode("\t", $file);
         if ($full) {
           $files[$both[0]] = array(
             'mask' => $mask | self::FLAG_DELETED,
             'ref'  => str_repeat('0', 40),
           );
         } else {
           $files[$both[0]] = $mask | self::FLAG_DELETED;
         }
         $file = $both[1];
         $mask |= self::FLAG_ADDED;
       } else if ($flag[0] == 'C') {
         $both = explode("\t", $file);
         $file = $both[1];
         $mask |= self::FLAG_ADDED;
       }
 
       if ($full) {
         $files[$file] = array(
           'mask' => $mask,
           'ref'  => $new_hash,
         );
       } else {
         $files[$file] = $mask;
       }
     }
 
     return $files;
   }
 
   public function getAllFiles() {
     $future = $this->buildLocalFuture(array('ls-files -z'));
     return id(new LinesOfALargeExecFuture($future))
       ->setDelimiter("\0");
   }
 
   public function getChangedFiles($since_commit) {
     list($stdout) = $this->execxLocal(
       'diff --raw %s',
       $since_commit);
     return $this->parseGitRawDiff($stdout);
   }
 
   public function getBlame($path) {
     list($stdout) = $this->execxLocal(
       'blame --porcelain -w -M %s -- %s',
       $this->getBaseCommit(),
       $path);
 
     // the --porcelain format prints at least one header line per source line,
     // then the source line prefixed by a tab character
     $blame_info = preg_split('/^\t.*\n/m', rtrim($stdout));
 
     // commit info is not repeated in these headers, so cache it
     $revision_data = array();
 
     $blame = array();
     foreach ($blame_info as $line_info) {
       $revision = substr($line_info, 0, 40);
       $data = idx($revision_data, $revision, array());
 
       if (empty($data)) {
         $matches = array();
         if (!preg_match('/^author (.*)$/m', $line_info, $matches)) {
           throw new Exception(
             pht(
               'Unexpected output from %s: no author for commit %s',
               'git blame',
               $revision));
         }
         $data['author'] = $matches[1];
         $data['from_first_commit'] = preg_match('/^boundary$/m', $line_info);
         $revision_data[$revision] = $data;
       }
 
       // Ignore lines predating the git repository (on a boundary commit)
       // rather than blaming them on the oldest diff's unfortunate author
       if (!$data['from_first_commit']) {
         $blame[] = array($data['author'], $revision);
       }
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getBaseCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision($path, 'HEAD');
   }
 
   private function parseGitTree($stdout) {
     $result = array();
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       return $result;
     }
 
     $lines = explode("\n", $stdout);
     foreach ($lines as $line) {
       $matches = array();
       $ok = preg_match(
         '/^(\d{6}) (blob|tree|commit) ([a-z0-9]{40})[\t](.*)$/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception(pht('Failed to parse %s output!', 'git ls-tree'));
       }
       $result[$matches[4]] = array(
         'mode' => $matches[1],
         'type' => $matches[2],
         'ref'  => $matches[3],
       );
     }
     return $result;
   }
 
   private function getFileDataAtRevision($path, $revision) {
     // NOTE: We don't want to just "git show {$revision}:{$path}" since if the
     // path was a directory at the given revision we'll get a list of its files
     // and treat it as though it as a file containing a list of other files,
     // which is silly.
 
     list($stdout) = $this->execxLocal(
       'ls-tree %s -- %s',
       $revision,
       $path);
 
     $info = $this->parseGitTree($stdout);
     if (empty($info[$path])) {
       // No such path, or the path is a directory and we executed 'ls-tree dir/'
       // and got a list of its contents back.
       return null;
     }
 
     if ($info[$path]['type'] != 'blob') {
       // Path is or was a directory, not a file.
       return null;
     }
 
     list($stdout) = $this->execxLocal(
       'cat-file blob %s',
        $info[$path]['ref']);
     return $stdout;
   }
 
   /**
    * Returns names of all the branches in the current repository.
    *
    * @return list<dict<string, string>> Dictionary of branch information.
    */
   public function getAllBranches() {
     $field_list = array(
       '%(refname)',
       '%(objectname)',
       '%(committerdate:raw)',
       '%(tree)',
       '%(subject)',
       '%(subject)%0a%0a%(body)',
       '%02',
     );
 
     list($stdout) = $this->execxLocal(
       'for-each-ref --format=%s -- refs/heads',
       implode('%01', $field_list));
 
     $current = $this->getBranchName();
     $result = array();
 
     $lines = explode("\2", $stdout);
     foreach ($lines as $line) {
       $line = trim($line);
       if (!strlen($line)) {
         continue;
       }
 
       $fields = explode("\1", $line, 6);
       list($ref, $hash, $epoch, $tree, $desc, $text) = $fields;
 
       $branch = $this->getBranchNameFromRef($ref);
       if ($branch) {
         $result[] = array(
           'current' => ($branch === $current),
           'name' => $branch,
           'hash' => $hash,
           'tree' => $tree,
           'epoch' => (int)$epoch,
           'desc' => $desc,
           'text' => $text,
         );
       }
     }
 
     return $result;
   }
 
   public function getWorkingCopyRevision() {
     list($stdout) = $this->execxLocal('rev-parse HEAD');
     return rtrim($stdout, "\n");
   }
 
   public function getUnderlyingWorkingCopyRevision() {
     list($err, $stdout) = $this->execManualLocal('svn find-rev HEAD');
     if (!$err && $stdout) {
       return rtrim($stdout, "\n");
     }
     return $this->getWorkingCopyRevision();
   }
 
   public function isHistoryDefaultImmutable() {
     return false;
   }
 
   public function supportsAmend() {
     return true;
   }
 
   public function supportsCommitRanges() {
     return true;
   }
 
   public function supportsLocalCommits() {
     return true;
   }
 
   public function hasLocalCommit($commit) {
     try {
       if (!$this->getCanonicalRevisionName($commit)) {
         return false;
       }
     } catch (CommandException $exception) {
       return false;
     }
     return true;
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullGitDiff($this->getBaseCommit());
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if (!$branch) {
       throw new ArcanistUsageException(
         pht('Under git, you must specify the branch you want to merge.'));
     }
     $err = phutil_passthru(
       '(cd %s && git merge --no-ff -m %s %s)',
       $this->getPath(),
       $message,
       $branch);
 
     if ($err) {
       throw new ArcanistUsageException(pht('Merge failed!'));
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return pht(
       "You may now push this commit upstream, as appropriate (e.g. with ".
       "'%s', or '%s', or by printing and faxing it).",
       'git push',
       'git svn dcommit');
   }
 
   public function getCommitMessage($commit) {
     list($message) = $this->execxLocal(
       'log -n1 --format=%C %s --',
       '%s%n%n%b',
       $commit);
     return $message;
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getGitCommitLog();
     if (!strlen($messages)) {
       return array();
     }
 
     $parser = new ArcanistDiffParser();
     $messages = $parser->parseDiff($messages);
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
         $message->getMetadata('message'));
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $message->getCommitHash();
       }
     }
 
     if ($revision_ids) {
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'ids' => $revision_ids,
         ));
 
       foreach ($results as $key => $result) {
         $hash = substr($reason_map[$result['id']], 0, 16);
         $results[$key]['why'] = pht(
           "Commit message for '%s' has explicit 'Differential Revision'.",
           $hash);
       }
 
       return $results;
     }
 
     // If we didn't succeed, try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('gtcm', $commit['commit']);
       $hashes[] = array('gttr', $commit['tree']);
     }
 
     $results = $conduit->callMethodSynchronous(
       'differential.query',
       $query + array(
         'commitHashes' => $hashes,
       ));
 
     foreach ($results as $key => $result) {
       $results[$key]['why'] = pht(
         'A git commit or tree hash in the commit range is already attached '.
         'to the Differential revision.');
     }
 
     return $results;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('pull');
     $this->reloadWorkingCopy();
   }
 
   public function getCommitSummary($commit) {
     if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
       return pht('(The Empty Tree)');
     }
 
     list($summary) = $this->execxLocal(
       'log -n 1 --format=%C %s',
       '%s',
       $commit);
 
     return trim($summary);
   }
 
   public function backoutCommit($commit_hash) {
     $this->execxLocal('revert %s -n --no-edit', $commit_hash);
     $this->reloadWorkingCopy();
     if (!$this->getUncommittedStatus()) {
       throw new ArcanistUsageException(
         pht('%s has already been reverted.', $commit_hash));
     }
   }
 
   public function getBackoutMessage($commit_hash) {
     return pht('This reverts commit %s.', $commit_hash);
   }
 
   public function isGitSubversionRepo() {
     return Filesystem::pathExists($this->getPath('.git/svn'));
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     list($type, $name) = explode(':', $rule, 2);
 
     switch ($type) {
       case 'git':
         $matches = null;
         if (preg_match('/^merge-base\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'merge-base %s HEAD',
             $matches[1]);
           if (!$err) {
             $this->setBaseCommitExplanation(
               pht(
                 "it is the merge-base of '%s' and HEAD, as specified by ".
                 "'%s' in your %s 'base' configuration.",
                 $matches[1],
                 $rule,
                 $source));
             return trim($merge_base);
           }
         } else if (preg_match('/^branch-unique\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'merge-base %s HEAD',
             $matches[1]);
           if ($err) {
             return null;
           }
           $merge_base = trim($merge_base);
 
           list($commits) = $this->execxLocal(
             'log --format=%C %s..HEAD --',
             '%H',
             $merge_base);
           $commits = array_filter(explode("\n", $commits));
 
           if (!$commits) {
             return null;
           }
 
           $commits[] = $merge_base;
 
           $head_branch_count = null;
           $all_branch_names = ipull($this->getAllBranches(), 'name');
           foreach ($commits as $commit) {
             // Ideally, we would use something like "for-each-ref --contains"
             // to get a filtered list of branches ready for script consumption.
             // Instead, try to get predictable output from "branch --contains".
 
             $flags = array();
             $flags[] = '--no-color';
 
             // NOTE: The "--no-column" flag was introduced in Git 1.7.11, so
             // don't pass it if we're running an older version. See T9953.
             $version = $this->getGitVersion();
             if (version_compare($version, '1.7.11', '>=')) {
               $flags[] = '--no-column';
             }
 
             list($branches) = $this->execxLocal(
               'branch %Ls --contains %s',
               $flags,
               $commit);
             $branches = array_filter(explode("\n", $branches));
 
             // Filter the list, removing the "current" marker (*) and ignoring
             // anything other than known branch names (mainly, any possible
             // "detached HEAD" or "no branch" line).
             foreach ($branches as $key => $branch) {
               $branch = trim($branch, ' *');
               if (in_array($branch, $all_branch_names)) {
                 $branches[$key] = $branch;
               } else {
                 unset($branches[$key]);
               }
             }
 
             if ($head_branch_count === null) {
               // If this is the first commit, it's HEAD. Count how many
               // branches it is on; we want to include commits on the same
               // number of branches. This covers a case where this branch
               // has sub-branches and we're running "arc diff" here again
               // for whatever reason.
               $head_branch_count = count($branches);
             } else if (count($branches) > $head_branch_count) {
               $branches = implode(', ', $branches);
               $this->setBaseCommitExplanation(
                 pht(
                   "it is the first commit between '%s' (the merge-base of ".
                   "'%s' and HEAD) which is also contained by another branch ".
                   "(%s).",
                   $merge_base,
                   $matches[1],
                   $branches));
               return $commit;
             }
           }
         } else {
           list($err) = $this->execManualLocal(
             'cat-file -t %s',
             $name);
           if (!$err) {
             $this->setBaseCommitExplanation(
               pht(
                 "it is specified by '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return $name;
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               pht(
                 "you specified '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return self::GIT_MAGIC_ROOT_COMMIT;
           case 'amended':
             $text = $this->getCommitMessage('HEAD');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 pht(
                   "HEAD has been amended with 'Differential Revision:', ".
                   "as specified by '%s' in your %s 'base' configuration.",
                   $rule,
                   $source));
               return 'HEAD^';
             }
             break;
           case 'upstream':
             list($err, $upstream) = $this->execManualLocal(
               'rev-parse --abbrev-ref --symbolic-full-name %s',
               '@{upstream}');
             if (!$err) {
               $upstream = rtrim($upstream);
               list($upstream_merge_base) = $this->execxLocal(
                 'merge-base %s HEAD',
                 $upstream);
               $upstream_merge_base = rtrim($upstream_merge_base);
               $this->setBaseCommitExplanation(
                 pht(
                   "it is the merge-base of the upstream of the current branch ".
                   "and HEAD, and matched the rule '%s' in your %s ".
                   "'base' configuration.",
                   $rule,
                   $source));
               return $upstream_merge_base;
             }
             break;
           case 'this':
             $this->setBaseCommitExplanation(
               pht(
                 "you specified '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return 'HEAD^';
         }
       default:
         return null;
     }
 
     return null;
   }
 
   public function canStashChanges() {
     return true;
   }
 
   public function stashChanges() {
     $this->execxLocal('stash');
     $this->reloadWorkingCopy();
   }
 
   public function unstashChanges() {
     $this->execxLocal('stash pop');
   }
 
   protected function didReloadCommitRange() {
     // After an amend, the symbolic head may resolve to a different commit.
     $this->resolvedHeadCommit = null;
   }
 
   /**
    * Follow the chain of tracking branches upstream until we reach a remote
    * or cycle locally.
    *
    * @param string Ref to start from.
    * @return list<wild> Path to an upstream.
    */
   public function getPathToUpstream($start) {
     $cursor = $start;
     $path = new ArcanistGitUpstreamPath();
     while (true) {
       list($err, $upstream) = $this->execManualLocal(
         'rev-parse --symbolic-full-name %s@{upstream}',
         $cursor);
 
       if ($err) {
         // We ended up somewhere with no tracking branch, so we're done.
         break;
       }
 
       $upstream = trim($upstream);
 
       if (preg_match('(^refs/heads/)', $upstream)) {
         $upstream = preg_replace('(^refs/heads/)', '', $upstream);
 
         $is_cycle = $path->getUpstream($upstream);
 
         $path->addUpstream(
           $cursor,
           array(
             'type' => ArcanistGitUpstreamPath::TYPE_LOCAL,
             'name' => $upstream,
             'cycle' => $is_cycle,
           ));
 
         if ($is_cycle) {
           // We ran into a local cycle, so we're done.
           break;
         }
 
         // We found another local branch, so follow that one upriver.
         $cursor = $upstream;
         continue;
       }
 
       if (preg_match('(^refs/remotes/)', $upstream)) {
         $upstream = preg_replace('(^refs/remotes/)', '', $upstream);
         list($remote, $branch) = explode('/', $upstream, 2);
 
         $path->addUpstream(
           $cursor,
           array(
             'type' => ArcanistGitUpstreamPath::TYPE_REMOTE,
             'name' => $branch,
             'remote' => $remote,
           ));
 
         // We found a remote, so we're done.
         break;
       }
 
       throw new Exception(
         pht(
           'Got unrecognized upstream format ("%s") from Git, expected '.
           '"refs/heads/..." or "refs/remotes/...".',
           $upstream));
     }
 
     return $path;
   }
 
 }
diff --git a/src/unit/parser/__tests__/XUnitTestResultParserTestCase.php b/src/unit/parser/__tests__/XUnitTestResultParserTestCase.php
index c26356d0..960bb46c 100644
--- a/src/unit/parser/__tests__/XUnitTestResultParserTestCase.php
+++ b/src/unit/parser/__tests__/XUnitTestResultParserTestCase.php
@@ -1,54 +1,54 @@
 <?php
 
 /**
  * Test for @{class:ArcanistXUnitTestResultParser}.
  */
 final class XUnitTestResultParserTestCase extends PhutilTestCase {
 
   public function testAcceptsNoTestsInput() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/xunit.no-tests');
     $parsed_results = id(new ArcanistXUnitTestResultParser())
       ->parseTestResults($stubbed_results);
 
     $this->assertEqual(0, count($parsed_results));
   }
 
   public function testAcceptsSimpleInput() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/xunit.simple');
     $parsed_results = id(new ArcanistXUnitTestResultParser())
       ->parseTestResults($stubbed_results);
 
     $this->assertEqual(3, count($parsed_results));
   }
 
   public function testEmptyInputFailure() {
     try {
       $parsed_results = id(new ArcanistXUnitTestResultParser())
         ->parseTestResults('');
 
-      $this->failTest(pht('Should throw on empty input'));
+      $this->assertFailure(pht('Should throw on empty input'));
     } catch (Exception $e) {
       // OK
     }
 
     $this->assertTrue(true);
   }
 
   public function testInvalidXmlInputFailure() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/xunit.invalid-xml');
     try {
       $parsed_results = id(new ArcanistXUnitTestResultParser())
         ->parseTestResults($stubbed_results);
 
-      $this->failTest(pht('Should throw on non-xml input'));
+      $this->assertFailure(pht('Should throw on non-xml input'));
     } catch (Exception $e) {
       // OK
     }
 
     $this->assertTrue(true);
   }
 
 }
diff --git a/src/workflow/ArcanistLandWorkflow.php b/src/workflow/ArcanistLandWorkflow.php
index 884f3a54..8323ce24 100644
--- a/src/workflow/ArcanistLandWorkflow.php
+++ b/src/workflow/ArcanistLandWorkflow.php
@@ -1,1571 +1,1569 @@
 <?php
 
 /**
  * Lands a branch by rebasing, merging and amending it.
  */
 final class ArcanistLandWorkflow extends ArcanistWorkflow {
 
   private $isGit;
   private $isGitSvn;
   private $isHg;
   private $isHgSvn;
 
   private $oldBranch;
   private $branch;
   private $onto;
   private $ontoRemoteBranch;
   private $remote;
   private $useSquash;
   private $keepBranch;
   private $shouldUpdateWithRebase;
   private $branchType;
   private $ontoType;
   private $preview;
 
   private $revision;
   private $messageFile;
 
   const REFTYPE_BRANCH = 'branch';
   const REFTYPE_BOOKMARK = 'bookmark';
 
   public function getRevisionDict() {
     return $this->revision;
   }
 
   public function getWorkflowName() {
     return 'land';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **land** [__options__] [__ref__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg
 
           Publish an accepted revision after review. This command is the last
           step in the standard Differential pre-publish code review workflow.
 
           This command merges and pushes changes associated with an accepted
           revision that are currently sitting in __ref__, which is usually the
           name of a local branch. Without __ref__, the current working copy
           state will be used.
 
           Under Git: branches, tags, and arbitrary commits (detached HEADs)
           may be landed.
 
           Under Mercurial: branches and bookmarks may be landed, but only
           onto a target of the same type. See T3855.
 
           The workflow selects a target branch to land onto and a remote where
           the change will be pushed to.
 
           A target branch is selected by examining these sources in order:
 
             - the **--onto** flag;
             - the upstream of the current branch, recursively (Git only);
             - the __arc.land.onto.default__ configuration setting;
             - or by falling back to a standard default:
               - "master" in Git;
               - "default" in Mercurial.
 
           A remote is selected by examining these sources in order:
 
             - the **--remote** flag;
             - the upstream of the current branch, recursively (Git only);
             - or by falling back to a standard default:
               - "origin" in Git;
               - the default remote in Mercurial.
 
           After selecting a target branch and a remote, the commits which will
           be landed are printed.
 
           With **--preview**, execution stops here, before the change is
           merged.
 
           The change is merged with the changes in the target branch,
           following these rules:
 
           In repositories with mutable history or with **--squash**, this will
           perform a squash merge (the entire branch will be represented as one
           commit after the merge).
 
           In repositories with immutable history or with **--merge**, this will
           perform a strict merge (a merge commit will always be created, and
           local commits will be preserved).
 
           The resulting commit will be given an up-to-date commit message
           describing the final state of the revision in Differential.
 
           In Git, the merge occurs in a detached HEAD. The local branch
           reference (if one exists) is not updated yet.
 
           With **--hold**, execution stops here, before the change is pushed.
 
           The change is pushed into the remote.
 
           Consulting mystical sources of power, the workflow makes a guess
           about what state you wanted to end up in after the process finishes
           and the working copy is put into that state.
 
           The branch which was landed is deleted, unless the **--keep-branch**
           flag was passed or the landing branch is the same as the target
           branch.
 
 EOTEXT
       );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function getArguments() {
     return array(
       'onto' => array(
         'param' => 'master',
         'help' => pht(
           "Land feature branch onto a branch other than the default ".
           "('master' in git, 'default' in hg). You can change the default ".
           "by setting '%s' with `%s` or for the entire project in %s.",
           'arc.land.onto.default',
           'arc set-config',
           '.arcconfig'),
       ),
       'hold' => array(
         'help' => pht(
           'Prepare the change to be pushed, but do not actually push it.'),
       ),
       'keep-branch' => array(
         'help' => pht(
           'Keep the feature branch after pushing changes to the '.
           'remote (by default, it is deleted).'),
       ),
       'remote' => array(
         'param' => 'origin',
         'help' => pht(
           "Push to a remote other than the default ('origin' in git)."),
       ),
       'merge' => array(
         'help' => pht(
           'Perform a %s merge, not a %s merge. If the project '.
           'is marked as having an immutable history, this is the default '.
           'behavior.',
           '--no-ff',
           '--squash'),
         'supports' => array(
           'git',
         ),
         'nosupport'   => array(
           'hg' => pht(
             'Use the %s strategy when landing in mercurial.',
             '--squash'),
         ),
       ),
       'squash' => array(
         'help' => pht(
           'Perform a %s merge, not a %s merge. If the project is '.
           'marked as having a mutable history, this is the default behavior.',
           '--squash',
           '--no-ff'),
         'conflicts' => array(
           'merge' => pht(
             '%s and %s are conflicting merge strategies.',
             '--merge',
             '--squash'),
         ),
       ),
       'delete-remote' => array(
         'help' => pht(
           'Delete the feature branch in the remote after landing it.'),
         'conflicts' => array(
           'keep-branch' => true,
         ),
       ),
       'update-with-rebase' => array(
         'help' => pht(
           "When updating the feature branch, use rebase instead of merge. ".
           "This might make things work better in some cases. Set ".
           "%s to '%s' to make this the default.",
           'arc.land.update.default',
           'rebase'),
         'conflicts' => array(
           'merge' => pht(
             'The %s strategy does not update the feature branch.',
             '--merge'),
           'update-with-merge' => pht(
             'Cannot be used with %s.',
             '--update-with-merge'),
         ),
         'supports' => array(
           'git',
         ),
       ),
       'update-with-merge' => array(
         'help' => pht(
           "When updating the feature branch, use merge instead of rebase. ".
           "This is the default behavior. Setting %s to '%s' can also be ".
           "used to make this the default.",
           'arc.land.update.default',
           'merge'),
         'conflicts' => array(
           'merge' => pht(
             'The %s strategy does not update the feature branch.',
             '--merge'),
           'update-with-rebase' => pht(
             'Cannot be used with %s.',
             '--update-with-rebase'),
         ),
         'supports' => array(
           'git',
         ),
       ),
       'revision' => array(
         'param' => 'id',
         'help' => pht(
           'Use the message from a specific revision, rather than '.
           'inferring the revision based on branch content.'),
       ),
       'preview' => array(
         'help' => pht(
           'Prints the commits that would be landed. Does not '.
           'actually modify or land the commits.'),
       ),
       '*' => 'branch',
     );
   }
 
   public function run() {
     $this->readArguments();
 
     $engine = null;
     if ($this->isGit && !$this->isGitSvn) {
       $engine = new ArcanistGitLandEngine();
     }
 
     if ($engine) {
       $this->readEngineArguments();
 
       $obsolete = array(
         'delete-remote',
         'update-with-merge',
         'update-with-rebase',
       );
 
       foreach ($obsolete as $flag) {
         if ($this->getArgument($flag)) {
           throw new ArcanistUsageException(
             pht(
               'Flag "%s" is no longer supported under Git.',
               '--'.$flag));
         }
       }
 
       $this->requireCleanWorkingCopy();
 
       $should_hold = $this->getArgument('hold');
 
       $engine
         ->setWorkflow($this)
         ->setRepositoryAPI($this->getRepositoryAPI())
         ->setSourceRef($this->branch)
         ->setTargetRemote($this->remote)
         ->setTargetOnto($this->onto)
         ->setShouldHold($should_hold)
         ->setShouldKeep($this->keepBranch)
         ->setShouldSquash($this->useSquash)
         ->setShouldPreview($this->preview)
         ->setBuildMessageCallback(array($this, 'buildEngineMessage'));
 
       $engine->execute();
 
       if (!$should_hold && !$this->preview) {
         $this->didPush();
       }
 
       return 0;
     }
 
     $this->validate();
 
     try {
       $this->pullFromRemote();
     } catch (Exception $ex) {
       $this->restoreBranch();
       throw $ex;
     }
 
     $this->printPendingCommits();
     if ($this->preview) {
       $this->restoreBranch();
       return 0;
     }
 
     $this->checkoutBranch();
     $this->findRevision();
 
     if ($this->useSquash) {
       $this->rebase();
       $this->squash();
     } else {
       $this->merge();
     }
 
     $this->push();
 
     if (!$this->keepBranch) {
       $this->cleanupBranch();
     }
 
     if ($this->oldBranch != $this->onto) {
       // If we were on some branch A and the user ran "arc land B",
       // switch back to A.
       if ($this->keepBranch || $this->oldBranch != $this->branch) {
         $this->restoreBranch();
       }
     }
 
     echo pht('Done.'), "\n";
 
     return 0;
   }
 
   private function getUpstreamMatching($branch, $pattern) {
     if ($this->isGit) {
       $repository_api = $this->getRepositoryAPI();
       list($err, $fullname) = $repository_api->execManualLocal(
         'rev-parse --symbolic-full-name %s@{upstream}',
         $branch);
       if (!$err) {
         $matches = null;
         if (preg_match($pattern, $fullname, $matches)) {
           return last($matches);
         }
       }
     }
     return null;
   }
 
   private function readEngineArguments() {
     // NOTE: This is hard-coded for Git right now.
     // TODO: Clean this up and move it into LandEngines.
 
     $onto = $this->getEngineOnto();
     $remote = $this->getEngineRemote();
 
     // This just overwrites work we did earlier, but it has to be up in this
     // class for now because other parts of the workflow still depend on it.
     $this->onto = $onto;
     $this->remote = $remote;
     $this->ontoRemoteBranch = $this->remote.'/'.$onto;
   }
 
   private function getEngineOnto() {
     $onto = $this->getArgument('onto');
     if ($onto !== null) {
       $this->writeInfo(
         pht('TARGET'),
         pht(
           'Landing onto "%s", selected by the --onto flag.',
           $onto));
       return $onto;
     }
 
     $api = $this->getRepositoryAPI();
     $path = $api->getPathToUpstream($this->branch);
 
     if ($path->getLength()) {
       $cycle = $path->getCycle();
       if ($cycle) {
         $this->writeWarn(
           pht('LOCAL CYCLE'),
           pht(
             'Local branch tracks an upstream, but following it leads to a '.
             'local cycle; ignoring branch upstream.'));
 
         echo tsprintf(
           "\n    %s\n\n",
           implode(' -> ', $cycle));
 
       } else {
         if ($path->isConnectedToRemote()) {
           $onto = $path->getRemoteBranchName();
           $this->writeInfo(
             pht('TARGET'),
             pht(
               'Landing onto "%s", selected by following tracking branches '.
               'upstream to the closest remote.',
               $onto));
           return $onto;
         } else {
           $this->writeInfo(
             pht('NO PATH TO UPSTREAM'),
             pht(
               'Local branch tracks an upstream, but there is no path '.
               'to a remote; ignoring branch upstream.'));
         }
       }
     }
 
     $config_key = 'arc.land.onto.default';
     $onto = $this->getConfigFromAnySource($config_key);
     if ($onto !== null) {
       $this->writeInfo(
         pht('TARGET'),
         pht(
           'Landing onto "%s", selected by "%s" configuration.',
           $onto,
           $config_key));
       return $onto;
     }
 
     $onto = 'master';
     $this->writeInfo(
       pht('TARGET'),
       pht(
         'Landing onto "%s", the default target under git.',
         $onto));
     return $onto;
   }
 
   private function getEngineRemote() {
     $remote = $this->getArgument('remote');
     if ($remote !== null) {
       $this->writeInfo(
         pht('REMOTE'),
         pht(
           'Using remote "%s", selected by the --remote flag.',
           $remote));
       return $remote;
     }
 
     $api = $this->getRepositoryAPI();
     $path = $api->getPathToUpstream($this->branch);
 
     $remote = $path->getRemoteRemoteName();
     if ($remote !== null) {
       $this->writeInfo(
         pht('REMOTE'),
         pht(
           'Using remote "%s", selected by following tracking branches '.
           'upstream to the closest remote.',
           $remote));
       return $remote;
     }
 
     $remote = 'origin';
     $this->writeInfo(
       pht('REMOTE'),
       pht(
         'Using remote "%s", the default remote under git.',
         $remote));
     return $remote;
   }
 
 
   private function readArguments() {
     $repository_api = $this->getRepositoryAPI();
     $this->isGit = $repository_api instanceof ArcanistGitAPI;
     $this->isHg = $repository_api instanceof ArcanistMercurialAPI;
 
     if ($this->isGit) {
       $repository = $this->loadProjectRepository();
       $this->isGitSvn = (idx($repository, 'vcs') == 'svn');
     }
 
     if ($this->isHg) {
       $this->isHgSvn = $repository_api->isHgSubversionRepo();
     }
 
     $branch = $this->getArgument('branch');
     if (empty($branch)) {
       $branch = $this->getBranchOrBookmark();
       if ($branch) {
         $this->branchType = $this->getBranchType($branch);
 
         // TODO: This message is misleading when landing a detached head or
         // a tag in Git.
 
         echo pht("Landing current %s '%s'.", $this->branchType, $branch), "\n";
         $branch = array($branch);
       }
     }
 
     if (count($branch) !== 1) {
       throw new ArcanistUsageException(
         pht('Specify exactly one branch or bookmark to land changes from.'));
     }
     $this->branch = head($branch);
     $this->keepBranch = $this->getArgument('keep-branch');
 
-    $update_strategy = $this->getConfigFromAnySource(
-      'arc.land.update.default',
-      'merge');
+    $update_strategy = $this->getConfigFromAnySource('arc.land.update.default');
     $this->shouldUpdateWithRebase = $update_strategy == 'rebase';
     if ($this->getArgument('update-with-rebase')) {
       $this->shouldUpdateWithRebase = true;
     } else if ($this->getArgument('update-with-merge')) {
       $this->shouldUpdateWithRebase = false;
     }
 
     $this->preview = $this->getArgument('preview');
 
     if (!$this->branchType) {
       $this->branchType = $this->getBranchType($this->branch);
     }
 
     $onto_default = $this->isGit ? 'master' : 'default';
     $onto_default = nonempty(
       $this->getConfigFromAnySource('arc.land.onto.default'),
       $onto_default);
     $onto_default = coalesce(
       $this->getUpstreamMatching($this->branch, '/^refs\/heads\/(.+)$/'),
       $onto_default);
     $this->onto = $this->getArgument('onto', $onto_default);
     $this->ontoType = $this->getBranchType($this->onto);
 
     $remote_default = $this->isGit ? 'origin' : '';
     $remote_default = coalesce(
       $this->getUpstreamMatching($this->onto, '/^refs\/remotes\/(.+?)\//'),
       $remote_default);
     $this->remote = $this->getArgument('remote', $remote_default);
 
     if ($this->getArgument('merge')) {
       $this->useSquash = false;
     } else if ($this->getArgument('squash')) {
       $this->useSquash = true;
     } else {
       $this->useSquash = !$this->isHistoryImmutable();
     }
 
     $this->ontoRemoteBranch = $this->onto;
     if ($this->isGitSvn) {
       $this->ontoRemoteBranch = 'trunk';
     } else if ($this->isGit) {
       $this->ontoRemoteBranch = $this->remote.'/'.$this->onto;
     }
 
     $this->oldBranch = $this->getBranchOrBookmark();
   }
 
   private function validate() {
     $repository_api = $this->getRepositoryAPI();
 
     if ($this->onto == $this->branch) {
       $message = pht(
         "You can not land a %s onto itself -- you are trying ".
         "to land '%s' onto '%s'. For more information on how to push ".
         "changes, see 'Pushing and Closing Revisions' in 'Arcanist User ".
         "Guide: arc diff' in the documentation.",
         $this->branchType,
         $this->branch,
         $this->onto);
       if (!$this->isHistoryImmutable()) {
         $message .= ' '.pht("You may be able to '%s' instead.", 'arc amend');
       }
       throw new ArcanistUsageException($message);
     }
 
     if ($this->isHg) {
       if ($this->useSquash) {
         if (!$repository_api->supportsRebase()) {
           throw new ArcanistUsageException(
             pht(
               'You must enable the rebase extension to use the %s strategy.',
               '--squash'));
         }
       }
 
       if ($this->branchType != $this->ontoType) {
         throw new ArcanistUsageException(pht(
           'Source %s is a %s but destination %s is a %s. When landing a '.
           '%s, the destination must also be a %s. Use %s to specify a %s, '.
           'or set %s in %s.',
           $this->branch,
           $this->branchType,
           $this->onto,
           $this->ontoType,
           $this->branchType,
           $this->branchType,
           '--onto',
           $this->branchType,
           'arc.land.onto.default',
           '.arcconfig'));
       }
     }
 
     if ($this->isGit) {
       list($err) = $repository_api->execManualLocal(
         'rev-parse --verify %s',
         $this->branch);
 
       if ($err) {
         throw new ArcanistUsageException(
           pht("Branch '%s' does not exist.", $this->branch));
       }
     }
 
     $this->requireCleanWorkingCopy();
   }
 
   private function checkoutBranch() {
     $repository_api = $this->getRepositoryAPI();
     if ($this->getBranchOrBookmark() != $this->branch) {
       $repository_api->execxLocal('checkout %s', $this->branch);
     }
 
     switch ($this->branchType) {
       case self::REFTYPE_BOOKMARK:
         $message = pht(
           'Switched to bookmark **%s**. Identifying and merging...',
           $this->branch);
         break;
       case self::REFTYPE_BRANCH:
       default:
         $message = pht(
           'Switched to branch **%s**. Identifying and merging...',
           $this->branch);
         break;
     }
 
     echo phutil_console_format($message."\n");
   }
 
   private function printPendingCommits() {
     $repository_api = $this->getRepositoryAPI();
 
     if ($repository_api instanceof ArcanistGitAPI) {
       list($out) = $repository_api->execxLocal(
         'log --oneline %s %s --',
         $this->branch,
         '^'.$this->onto);
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $common_ancestor = $repository_api->getCanonicalRevisionName(
         hgsprintf('ancestor(%s,%s)',
           $this->onto,
           $this->branch));
 
       $branch_range = hgsprintf(
         'reverse((%s::%s) - %s)',
         $common_ancestor,
         $this->branch,
         $common_ancestor);
 
       list($out) = $repository_api->execxLocal(
         'log -r %s --template %s',
         $branch_range,
         '{node|short} {desc|firstline}\n');
     }
 
     if (!trim($out)) {
       $this->restoreBranch();
       throw new ArcanistUsageException(
         pht('No commits to land from %s.', $this->branch));
     }
 
     echo pht("The following commit(s) will be landed:\n\n%s", $out), "\n";
   }
 
   private function findRevision() {
     $repository_api = $this->getRepositoryAPI();
 
     $this->parseBaseCommitArgument(array($this->ontoRemoteBranch));
 
     $revision_id = $this->getArgument('revision');
     if ($revision_id) {
       $revision_id = $this->normalizeRevisionID($revision_id);
       $revisions = $this->getConduit()->callMethodSynchronous(
         'differential.query',
         array(
           'ids' => array($revision_id),
         ));
       if (!$revisions) {
         throw new ArcanistUsageException(pht(
           "No such revision '%s'!",
           "D{$revision_id}"));
       }
     } else {
       $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
         $this->getConduit(),
         array());
     }
 
     if (!count($revisions)) {
       throw new ArcanistUsageException(pht(
         "arc can not identify which revision exists on %s '%s'. Update the ".
         "revision with recent changes to synchronize the %s name and hashes, ".
         "or use '%s' to amend the commit message at HEAD, or use ".
         "'%s' to select a revision explicitly.",
         $this->branchType,
         $this->branch,
         $this->branchType,
         'arc amend',
         '--revision <id>'));
     } else if (count($revisions) > 1) {
       switch ($this->branchType) {
         case self::REFTYPE_BOOKMARK:
           $message = pht(
             "There are multiple revisions on feature bookmark '%s' which are ".
             "not present on '%s':\n\n".
             "%s\n".
             'Separate these revisions onto different bookmarks, or use '.
             '--revision <id> to use the commit message from <id> '.
             'and land them all.',
             $this->branch,
             $this->onto,
             $this->renderRevisionList($revisions));
           break;
         case self::REFTYPE_BRANCH:
         default:
           $message = pht(
             "There are multiple revisions on feature branch '%s' which are ".
             "not present on '%s':\n\n".
             "%s\n".
             'Separate these revisions onto different branches, or use '.
             '--revision <id> to use the commit message from <id> '.
             'and land them all.',
             $this->branch,
             $this->onto,
             $this->renderRevisionList($revisions));
           break;
       }
 
       throw new ArcanistUsageException($message);
     }
 
     $this->revision = head($revisions);
 
     $rev_status = $this->revision['status'];
     $rev_id = $this->revision['id'];
     $rev_title = $this->revision['title'];
     $rev_auxiliary = idx($this->revision, 'auxiliary', array());
 
     if ($this->revision['authorPHID'] != $this->getUserPHID()) {
       $other_author = $this->getConduit()->callMethodSynchronous(
         'user.query',
         array(
           'phids' => array($this->revision['authorPHID']),
         ));
       $other_author = ipull($other_author, 'userName', 'phid');
       $other_author = $other_author[$this->revision['authorPHID']];
       $ok = phutil_console_confirm(pht(
         "This %s has revision '%s' but you are not the author. Land this ".
         "revision by %s?",
         $this->branchType,
         "D{$rev_id}: {$rev_title}",
         $other_author));
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     if ($rev_status != ArcanistDifferentialRevisionStatus::ACCEPTED) {
       $ok = phutil_console_confirm(pht(
         "Revision '%s' has not been accepted. Continue anyway?",
         "D{$rev_id}: {$rev_title}"));
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     if ($rev_auxiliary) {
       $phids = idx($rev_auxiliary, 'phabricator:depends-on', array());
       if ($phids) {
         $dep_on_revs = $this->getConduit()->callMethodSynchronous(
           'differential.query',
            array(
              'phids' => $phids,
              'status' => 'status-open',
            ));
 
         $open_dep_revs = array();
         foreach ($dep_on_revs as $dep_on_rev) {
           $dep_on_rev_id = $dep_on_rev['id'];
           $dep_on_rev_title = $dep_on_rev['title'];
           $dep_on_rev_status = $dep_on_rev['status'];
           $open_dep_revs[$dep_on_rev_id] = $dep_on_rev_title;
         }
 
         if (!empty($open_dep_revs)) {
           $open_revs = array();
           foreach ($open_dep_revs as $id => $title) {
             $open_revs[] = '    - D'.$id.': '.$title;
           }
           $open_revs = implode("\n", $open_revs);
 
           echo pht(
             "Revision '%s' depends on open revisions:\n\n%s",
             "D{$rev_id}: {$rev_title}",
             $open_revs);
 
           $ok = phutil_console_confirm(pht('Continue anyway?'));
           if (!$ok) {
             throw new ArcanistUserAbortException();
           }
         }
       }
     }
 
     $message = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => $rev_id,
       ));
 
     $this->messageFile = new TempFile();
     Filesystem::writeFile($this->messageFile, $message);
 
     echo pht(
       "Landing revision '%s'...",
       "D{$rev_id}: {$rev_title}")."\n";
 
     $diff_phid = idx($this->revision, 'activeDiffPHID');
     if ($diff_phid) {
       $this->checkForBuildables($diff_phid);
     }
   }
 
   private function pullFromRemote() {
     $repository_api = $this->getRepositoryAPI();
 
     $local_ahead_of_remote = false;
     if ($this->isGit) {
       $repository_api->execxLocal('checkout %s', $this->onto);
 
       echo phutil_console_format(pht(
         "Switched to branch **%s**. Updating branch...\n",
         $this->onto));
 
       try {
         $repository_api->execxLocal('pull --ff-only --no-stat');
       } catch (CommandException $ex) {
         if (!$this->isGitSvn) {
           throw $ex;
         }
       }
       list($out) = $repository_api->execxLocal(
         'log %s..%s',
         $this->ontoRemoteBranch,
         $this->onto);
       if (strlen(trim($out))) {
         $local_ahead_of_remote = true;
       } else if ($this->isGitSvn) {
         $repository_api->execxLocal('svn rebase');
       }
 
     } else if ($this->isHg) {
       echo phutil_console_format(pht('Updating **%s**...', $this->onto)."\n");
 
       try {
         list($out, $err) = $repository_api->execxLocal('pull');
 
         $divergedbookmark = $this->onto.'@'.$repository_api->getBranchName();
         if (strpos($err, $divergedbookmark) !== false) {
           throw new ArcanistUsageException(phutil_console_format(pht(
             "Local bookmark **%s** has diverged from the server's **%s** ".
             "(now labeled **%s**). Please resolve this divergence and run ".
             "'%s' again.",
             $this->onto,
             $this->onto,
             $divergedbookmark,
             'arc land')));
         }
       } catch (CommandException $ex) {
         $err = $ex->getError();
         $stdout = $ex->getStdOut();
 
         // Copied from: PhabricatorRepositoryPullLocalDaemon.php
         // NOTE: Between versions 2.1 and 2.1.1, Mercurial changed the
         // behavior of "hg pull" to return 1 in case of a successful pull
         // with no changes. This behavior has been reverted, but users who
         // updated between Feb 1, 2012 and Mar 1, 2012 will have the
         // erroring version. Do a dumb test against stdout to check for this
         // possibility.
         // See: https://github.com/phacility/phabricator/issues/101/
 
         // NOTE: Mercurial has translated versions, which translate this error
         // string. In a translated version, the string will be something else,
         // like "aucun changement trouve". There didn't seem to be an easy way
         // to handle this (there are hard ways but this is not a common
         // problem and only creates log spam, not application failures).
         // Assume English.
 
         // TODO: Remove this once we're far enough in the future that
         // deployment of 2.1 is exceedingly rare?
         if ($err != 1 || !preg_match('/no changes found/', $stdout)) {
           throw $ex;
         }
       }
 
       // Pull succeeded. Now make sure master is not on an outgoing change
       if ($repository_api->supportsPhases()) {
         list($out) = $repository_api->execxLocal(
           'log -r %s --template %s', $this->onto, '{phase}');
         if ($out != 'public') {
           $local_ahead_of_remote = true;
         }
       } else {
         // execManual instead of execx because outgoing returns
         // code 1 when there is nothing outgoing
         list($err, $out) = $repository_api->execManualLocal(
           'outgoing -r %s',
           $this->onto);
 
         // $err === 0 means something is outgoing
         if ($err === 0) {
           $local_ahead_of_remote = true;
         }
       }
     }
 
     if ($local_ahead_of_remote) {
       throw new ArcanistUsageException(pht(
         "Local %s '%s' is ahead of remote %s '%s', so landing a feature ".
         "%s would push additional changes. Push or reset the changes in '%s' ".
         "before running '%s'.",
         $this->ontoType,
         $this->onto,
         $this->ontoType,
         $this->ontoRemoteBranch,
         $this->ontoType,
         $this->onto,
         'arc land'));
     }
   }
 
   private function rebase() {
     $repository_api = $this->getRepositoryAPI();
 
     chdir($repository_api->getPath());
     if ($this->isGit) {
       if ($this->shouldUpdateWithRebase) {
         echo phutil_console_format(pht(
           'Rebasing **%s** onto **%s**',
           $this->branch,
           $this->onto)."\n");
         $err = phutil_passthru('git rebase %s', $this->onto);
         if ($err) {
           throw new ArcanistUsageException(pht(
             "'%s' failed. You can abort with '%s', or resolve conflicts ".
             "and use '%s' to continue forward. After resolving the rebase, ".
             "run '%s' again.",
             sprintf('git rebase %s', $this->onto),
             'git rebase --abort',
             'git rebase --continue',
             'arc land'));
         }
       } else {
         echo phutil_console_format(pht(
           'Merging **%s** into **%s**',
           $this->branch,
           $this->onto)."\n");
         $err = phutil_passthru(
           'git merge --no-stat %s -m %s',
           $this->onto,
           pht("Automatic merge by '%s'", 'arc land'));
         if ($err) {
           throw new ArcanistUsageException(pht(
             "'%s' failed. To continue: resolve the conflicts, commit ".
             "the changes, then run '%s' again. To abort: run '%s'.",
             sprintf('git merge %s', $this->onto),
             'arc land',
             'git merge --abort'));
         }
       }
     } else if ($this->isHg) {
       $onto_tip = $repository_api->getCanonicalRevisionName($this->onto);
       $common_ancestor = $repository_api->getCanonicalRevisionName(
         hgsprintf('ancestor(%s, %s)', $this->onto, $this->branch));
 
       // Only rebase if the local branch is not at the tip of the onto branch.
       if ($onto_tip != $common_ancestor) {
         // keep branch here so later we can decide whether to remove it
         $err = $repository_api->execPassthru(
           'rebase -d %s --keepbranches',
           $this->onto);
         if ($err) {
           echo phutil_console_format("%s\n", pht('Aborting rebase'));
           $repository_api->execManualLocal('rebase --abort');
           $this->restoreBranch();
           throw new ArcanistUsageException(pht(
             "'%s' failed and the rebase was aborted. This is most ".
             "likely due to conflicts. Manually rebase %s onto %s, resolve ".
             "the conflicts, then run '%s' again.",
             sprintf('hg rebase %s', $this->onto),
             $this->branch,
             $this->onto,
             'arc land'));
         }
       }
     }
 
     $repository_api->reloadWorkingCopy();
   }
 
   private function squash() {
     $repository_api = $this->getRepositoryAPI();
 
     if ($this->isGit) {
       $repository_api->execxLocal('checkout %s', $this->onto);
       $repository_api->execxLocal(
         'merge --no-stat --squash --ff-only %s',
         $this->branch);
     } else if ($this->isHg) {
       // The hg code is a little more complex than git's because we
       // need to handle the case where the landing branch has child branches:
       // -a--------b  master
       //   \
       //    w--x  mybranch
       //        \--y  subbranch1
       //         \--z  subbranch2
       //
       // arc land --branch mybranch --onto master :
       // -a--b--wx  master
       //          \--y  subbranch1
       //           \--z  subbranch2
 
       $branch_rev_id = $repository_api->getCanonicalRevisionName($this->branch);
 
       // At this point $this->onto has been pulled from remote and
       // $this->branch has been rebased on top of onto(by the rebase()
       // function). So we're guaranteed to have onto as an ancestor of branch
       // when we use first((onto::branch)-onto) below.
       $branch_root = $repository_api->getCanonicalRevisionName(
         hgsprintf('first((%s::%s)-%s)',
           $this->onto,
           $this->branch,
           $this->onto));
 
       $branch_range = hgsprintf(
         '(%s::%s)',
         $branch_root,
         $this->branch);
 
       if (!$this->keepBranch) {
         $this->handleAlternateBranches($branch_root, $branch_range);
       }
 
       // Collapse just the landing branch onto master.
       // Leave its children on the original branch.
       $err = $repository_api->execPassthru(
         'rebase --collapse --keep --logfile %s -r %s -d %s',
         $this->messageFile,
         $branch_range,
         $this->onto);
 
       if ($err) {
         $repository_api->execManualLocal('rebase --abort');
         $this->restoreBranch();
         throw new ArcanistUsageException(
           pht(
             "Squashing the commits under %s failed. ".
             "Manually squash your commits and run '%s' again.",
             $this->branch,
             'arc land'));
       }
 
       if ($repository_api->isBookmark($this->branch)) {
         // a bug in mercurial means bookmarks end up on the revision prior
         // to the collapse when using --collapse with --keep,
         // so we manually move them to the correct spots
         // see: http://bz.selenic.com/show_bug.cgi?id=3716
         $repository_api->execxLocal(
           'bookmark -f %s',
           $this->onto);
 
         $repository_api->execxLocal(
           'bookmark -f %s -r %s',
           $this->branch,
           $branch_rev_id);
       }
 
       // check if the branch had children
       list($output) = $repository_api->execxLocal(
         'log -r %s --template %s',
         hgsprintf('children(%s)', $this->branch),
         '{node}\n');
 
       $child_branch_roots = phutil_split_lines($output, false);
       $child_branch_roots = array_filter($child_branch_roots);
       if ($child_branch_roots) {
         // move the branch's children onto the collapsed commit
         foreach ($child_branch_roots as $child_root) {
           $repository_api->execxLocal(
             'rebase -d %s -s %s --keep --keepbranches',
             $this->onto,
             $child_root);
         }
       }
 
       // All the rebases may have moved us to another branch
       // so we move back.
       $repository_api->execxLocal('checkout %s', $this->onto);
     }
   }
 
   /**
    * Detect alternate branches and prompt the user for how to handle
    * them. An alternate branch is a branch that forks from the landing
    * branch prior to the landing branch tip.
    *
    * In a situation like this:
    *   -a--------b  master
    *     \
    *      w--x  landingbranch
    *       \  \-- g subbranch
    *        \--y  altbranch1
    *         \--z  altbranch2
    *
    * y and z are alternate branches and will get deleted by the squash,
    * so we need to detect them and ask the user what they want to do.
    *
    * @param string The revision id of the landing branch's root commit.
    * @param string The revset specifying all the commits in the landing branch.
    * @return void
    */
   private function handleAlternateBranches($branch_root, $branch_range) {
     $repository_api = $this->getRepositoryAPI();
 
     // Using the tree in the doccomment, the revset below resolves as follows:
     // 1. roots(descendants(w) - descendants(x) - (w::x))
     // 2. roots({x,g,y,z} - {g} - {w,x})
     // 3. roots({y,z})
     // 4. {y,z}
     $alt_branch_revset = hgsprintf(
       'roots(descendants(%s)-descendants(%s)-%R)',
       $branch_root,
       $this->branch,
       $branch_range);
     list($alt_branches) = $repository_api->execxLocal(
       'log --template %s -r %s',
       '{node}\n',
        $alt_branch_revset);
 
     $alt_branches = phutil_split_lines($alt_branches, false);
     $alt_branches = array_filter($alt_branches);
 
     $alt_count = count($alt_branches);
     if ($alt_count > 0) {
       $input = phutil_console_prompt(pht(
         "%s '%s' has %s %s(s) forking off of it that would be deleted ".
         "during a squash. Would you like to keep a non-squashed copy, rebase ".
         "them on top of '%s', or abort and deal with them yourself? ".
         "(k)eep, (r)ebase, (a)bort:",
         ucfirst($this->branchType),
         $this->branch,
         $alt_count,
         $this->branchType,
         $this->branch));
 
       if ($input == 'k' || $input == 'keep') {
         $this->keepBranch = true;
       } else if ($input == 'r' || $input == 'rebase') {
         foreach ($alt_branches as $alt_branch) {
           $repository_api->execxLocal(
             'rebase --keep --keepbranches -d %s -s %s',
             $this->branch,
             $alt_branch);
         }
       } else if ($input == 'a' || $input == 'abort') {
         $branch_string = implode("\n", $alt_branches);
         echo
           "\n",
           pht(
             "Remove the %s starting at these revisions and run %s again:\n%s",
             $this->branchType.'s',
             $branch_string,
             'arc land'),
           "\n\n";
         throw new ArcanistUserAbortException();
       } else {
         throw new ArcanistUsageException(
           pht('Invalid choice. Aborting arc land.'));
       }
     }
   }
 
   private function merge() {
     $repository_api = $this->getRepositoryAPI();
 
     // In immutable histories, do a --no-ff merge to force a merge commit with
     // the right message.
     $repository_api->execxLocal('checkout %s', $this->onto);
 
     chdir($repository_api->getPath());
     if ($this->isGit) {
       $err = phutil_passthru(
         'git merge --no-stat --no-ff --no-commit %s',
         $this->branch);
 
       if ($err) {
         throw new ArcanistUsageException(pht(
           "'%s' failed. Your working copy has been left in a partially ".
           "merged state. You can: abort with '%s'; or follow the ".
           "instructions to complete the merge.",
           'git merge',
           'git merge --abort'));
       }
     } else if ($this->isHg) {
       // HG arc land currently doesn't support --merge.
       // When merging a bookmark branch to a master branch that
       // hasn't changed since the fork, mercurial fails to merge.
       // Instead of only working in some cases, we just disable --merge
       // until there is a demand for it.
       // The user should never reach this line, since --merge is
       // forbidden at the command line argument level.
       throw new ArcanistUsageException(
         pht('%s is not currently supported for hg repos.', '--merge'));
     }
   }
 
   private function push() {
     $repository_api = $this->getRepositoryAPI();
 
     // These commands can fail legitimately (e.g. commit hooks)
     try {
       if ($this->isGit) {
         $repository_api->execxLocal('commit -F %s', $this->messageFile);
         if (phutil_is_windows()) {
           // Occasionally on large repositories on Windows, Git can exit with
           // an unclean working copy here. This prevents reverts from being
           // pushed to the remote when this occurs.
           $this->requireCleanWorkingCopy();
         }
       } else if ($this->isHg) {
         // hg rebase produces a commit earlier as part of rebase
         if (!$this->useSquash) {
           $repository_api->execxLocal(
             'commit --logfile %s',
             $this->messageFile);
         }
       }
       // We dispatch this event so we can run checks on the merged revision,
       // right before it gets pushed out. It's easier to do this in arc land
       // than to try to hook into git/hg.
       $this->didCommitMerge();
     } catch (Exception $ex) {
       $this->executeCleanupAfterFailedPush();
       throw $ex;
     }
 
     if ($this->getArgument('hold')) {
       echo phutil_console_format(pht(
         'Holding change in **%s**: it has NOT been pushed yet.',
         $this->onto)."\n");
     } else {
       echo pht('Pushing change...'), "\n\n";
 
       chdir($repository_api->getPath());
 
       if ($this->isGitSvn) {
         $err = phutil_passthru('git svn dcommit');
         $cmd = 'git svn dcommit';
       } else if ($this->isGit) {
         $err = phutil_passthru('git push %s %s', $this->remote, $this->onto);
         $cmd = 'git push';
       } else if ($this->isHgSvn) {
         // hg-svn doesn't support 'push -r', so we do a normal push
         // which hg-svn modifies to only push the current branch and
         // ancestors.
         $err = $repository_api->execPassthru('push %s', $this->remote);
         $cmd = 'hg push';
       } else if ($this->isHg) {
         if (strlen($this->remote)) {
           $err = $repository_api->execPassthru(
             'push -r %s %s',
             $this->onto,
             $this->remote);
         } else {
           $err = $repository_api->execPassthru(
             'push -r %s',
             $this->onto);
         }
         $cmd = 'hg push';
       }
 
       if ($err) {
         echo phutil_console_format(
           "<bg:red>**   %s   **</bg>\n",
           pht('PUSH FAILED!'));
         $this->executeCleanupAfterFailedPush();
         if ($this->isGit) {
           throw new ArcanistUsageException(pht(
             "'%s' failed! Fix the error and run '%s' again.",
             $cmd,
             'arc land'));
         }
         throw new ArcanistUsageException(pht(
           "'%s' failed! Fix the error and push this change manually.",
           $cmd));
       }
 
       $this->didPush();
 
       echo "\n";
     }
   }
 
   private function executeCleanupAfterFailedPush() {
     $repository_api = $this->getRepositoryAPI();
     if ($this->isGit) {
       $repository_api->execxLocal('reset --hard HEAD^');
       $this->restoreBranch();
     } else if ($this->isHg) {
       $repository_api->execxLocal(
         '--config extensions.mq= strip %s',
         $this->onto);
       $this->restoreBranch();
     }
   }
 
   private function cleanupBranch() {
     $repository_api = $this->getRepositoryAPI();
 
     echo pht('Cleaning up feature %s...', $this->branchType), "\n";
     if ($this->isGit) {
       list($ref) = $repository_api->execxLocal(
         'rev-parse --verify %s',
         $this->branch);
       $ref = trim($ref);
       $recovery_command = csprintf(
         'git checkout -b %s %s',
         $this->branch,
         $ref);
       echo pht('(Use `%s` if you want it back.)', $recovery_command), "\n";
       $repository_api->execxLocal('branch -D %s', $this->branch);
     } else if ($this->isHg) {
       $common_ancestor = $repository_api->getCanonicalRevisionName(
         hgsprintf('ancestor(%s,%s)', $this->onto, $this->branch));
 
       $branch_root = $repository_api->getCanonicalRevisionName(
         hgsprintf('first((%s::%s)-%s)',
           $common_ancestor,
           $this->branch,
           $common_ancestor));
 
       $repository_api->execxLocal(
         '--config extensions.mq= strip -r %s',
         $branch_root);
 
       if ($repository_api->isBookmark($this->branch)) {
         $repository_api->execxLocal('bookmark -d %s', $this->branch);
       }
     }
 
     if ($this->getArgument('delete-remote')) {
       if ($this->isGit) {
         list($err, $ref) = $repository_api->execManualLocal(
           'rev-parse --verify %s/%s',
           $this->remote,
           $this->branch);
 
         if ($err) {
           echo pht(
             'No remote feature %s to clean up.',
             $this->branchType);
           echo "\n";
         } else {
 
           // NOTE: In Git, you delete a remote branch by pushing it with a
           // colon in front of its name:
           //
           //   git push <remote> :<branch>
 
           echo pht('Cleaning up remote feature %s...', $this->branchType), "\n";
           $repository_api->execxLocal(
             'push %s :%s',
             $this->remote,
             $this->branch);
         }
       } else if ($this->isHg) {
         // named branches were closed as part of the earlier commit
         // so only worry about bookmarks
         if ($repository_api->isBookmark($this->branch)) {
           $repository_api->execxLocal(
             'push -B %s %s',
             $this->branch,
             $this->remote);
         }
       }
     }
   }
 
   public function getSupportedRevisionControlSystems() {
     return array('git', 'hg');
   }
 
   private function getBranchOrBookmark() {
     $repository_api = $this->getRepositoryAPI();
     if ($this->isGit) {
       $branch = $repository_api->getBranchName();
 
       // If we don't have a branch name, just use whatever's at HEAD.
       if (!strlen($branch) && !$this->isGitSvn) {
         $branch = $repository_api->getWorkingCopyRevision();
       }
     } else if ($this->isHg) {
       $branch = $repository_api->getActiveBookmark();
       if (!$branch) {
         $branch = $repository_api->getBranchName();
       }
     }
 
     return $branch;
   }
 
   private function getBranchType($branch) {
     $repository_api = $this->getRepositoryAPI();
     if ($this->isHg && $repository_api->isBookmark($branch)) {
       return 'bookmark';
     }
     return 'branch';
   }
 
   /**
    * Restore the original branch, e.g. after a successful land or a failed
    * pull.
    */
   private function restoreBranch() {
     $repository_api = $this->getRepositoryAPI();
     $repository_api->execxLocal('checkout %s', $this->oldBranch);
     if ($this->isGit) {
       $repository_api->execxLocal('submodule update --init --recursive');
     }
     echo pht(
       "Switched back to %s %s.\n",
       $this->branchType,
       phutil_console_format('**%s**', $this->oldBranch));
   }
 
 
   /**
    * Check if a diff has a running or failed buildable, and prompt the user
    * before landing if it does.
    */
   private function checkForBuildables($diff_phid) {
     // NOTE: Since Harbormaster is still beta and this stuff all got added
     // recently, just bail if we can't find a buildable. This is just an
     // advisory check intended to prevent human error.
 
     try {
       $buildables = $this->getConduit()->callMethodSynchronous(
         'harbormaster.querybuildables',
         array(
           'buildablePHIDs' => array($diff_phid),
           'manualBuildables' => false,
         ));
     } catch (ConduitClientException $ex) {
       return;
     }
 
     if (!$buildables['data']) {
       // If there's no corresponding buildable, we're done.
       return;
     }
 
     $console = PhutilConsole::getConsole();
 
     $buildable = head($buildables['data']);
 
     if ($buildable['buildableStatus'] == 'passed') {
       $console->writeOut(
         "**<bg:green> %s </bg>** %s\n",
         pht('BUILDS PASSED'),
         pht('Harbormaster builds for the active diff completed successfully.'));
       return;
     }
 
     switch ($buildable['buildableStatus']) {
       case 'building':
         $message = pht(
           'Harbormaster is still building the active diff for this revision:');
         $prompt = pht('Land revision anyway, despite ongoing build?');
         break;
       case 'failed':
         $message = pht(
           'Harbormaster failed to build the active diff for this revision. '.
           'Build failures:');
         $prompt = pht('Land revision anyway, despite build failures?');
         break;
       default:
         // If we don't recognize the status, just bail.
         return;
     }
 
     $builds = $this->getConduit()->callMethodSynchronous(
       'harbormaster.querybuilds',
       array(
         'buildablePHIDs' => array($buildable['phid']),
       ));
 
     $console->writeOut($message."\n\n");
     foreach ($builds['data'] as $build) {
       switch ($build['buildStatus']) {
         case 'failed':
           $color = 'red';
           break;
         default:
           $color = 'yellow';
           break;
       }
 
       $console->writeOut(
         "    **<bg:".$color."> %s </bg>** %s: %s\n",
         phutil_utf8_strtoupper($build['buildStatusName']),
         pht('Build %d', $build['id']),
         $build['name']);
     }
 
     $console->writeOut(
       "\n%s\n\n    **%s**: __%s__",
       pht('You can review build details here:'),
       pht('Harbormaster URI'),
       $buildable['uri']);
 
     if (!$console->confirm($prompt)) {
       throw new ArcanistUserAbortException();
     }
   }
 
   public function buildEngineMessage(ArcanistLandEngine $engine) {
     // TODO: This is oh-so-gross.
     $this->findRevision();
     $engine->setCommitMessageFile($this->messageFile);
   }
 
   public function didCommitMerge() {
     $this->dispatchEvent(
       ArcanistEventType::TYPE_LAND_WILLPUSHREVISION,
       array());
   }
 
   public function didPush() {
     $this->askForRepositoryUpdate();
 
     $mark_workflow = $this->buildChildWorkflow(
       'close-revision',
       array(
         '--finalize',
         '--quiet',
         $this->revision['id'],
       ));
     $mark_workflow->run();
   }
 
 }
diff --git a/src/workflow/ArcanistLintWorkflow.php b/src/workflow/ArcanistLintWorkflow.php
index bb53cde7..36126c5d 100644
--- a/src/workflow/ArcanistLintWorkflow.php
+++ b/src/workflow/ArcanistLintWorkflow.php
@@ -1,662 +1,662 @@
 <?php
 
 /**
  * Runs lint rules on changes.
  */
 final class ArcanistLintWorkflow extends ArcanistWorkflow {
 
   const RESULT_OKAY       = 0;
   const RESULT_WARNINGS   = 1;
   const RESULT_ERRORS     = 2;
   const RESULT_SKIP       = 3;
 
   const DEFAULT_SEVERITY = ArcanistLintSeverity::SEVERITY_ADVICE;
 
   private $unresolvedMessages;
   private $shouldLintAll;
   private $shouldAmendChanges = false;
   private $shouldAmendWithoutPrompt = false;
   private $shouldAmendAutofixesWithoutPrompt = false;
   private $engine;
 
   public function getWorkflowName() {
     return 'lint';
   }
 
   public function setShouldAmendChanges($should_amend) {
     $this->shouldAmendChanges = $should_amend;
     return $this;
   }
 
   public function setShouldAmendWithoutPrompt($should_amend) {
     $this->shouldAmendWithoutPrompt = $should_amend;
     return $this;
   }
 
   public function setShouldAmendAutofixesWithoutPrompt($should_amend) {
     $this->shouldAmendAutofixesWithoutPrompt = $should_amend;
     return $this;
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **lint** [__options__] [__paths__]
       **lint** [__options__] --rev [__rev__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Run static analysis on changes to check for mistakes. If no files
           are specified, lint will be run on all files which have been modified.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'lintall' => array(
         'help' => pht(
           'Show all lint warnings, not just those on changed lines. When '.
           'paths are specified, this is the default behavior.'),
         'conflicts' => array(
           'only-changed' => true,
         ),
       ),
       'only-changed' => array(
         'help' => pht(
           'Show lint warnings just on changed lines. When no paths are '.
           'specified, this is the default. This differs from only-new '.
           'in cases where line modifications introduce lint on other '.
           'unmodified lines.'),
         'conflicts' => array(
           'lintall' => true,
         ),
       ),
       'rev' => array(
         'param' => 'revision',
         'help' => pht('Lint changes since a specific revision.'),
         'supports' => array(
           'git',
           'hg',
         ),
         'nosupport' => array(
           'svn' => pht('Lint does not currently support %s in SVN.', '--rev'),
         ),
       ),
       'output' => array(
         'param' => 'format',
         'help' => pht(
           "With 'summary', show lint warnings in a more compact format. ".
           "With 'json', show lint warnings in machine-readable JSON format. ".
           "With 'none', show no lint warnings. ".
           "With 'compiler', show lint warnings in suitable for your editor. ".
           "With 'xml', show lint warnings in the Checkstyle XML format."),
       ),
       'outfile' => array(
         'param' => 'path',
         'help' => pht(
           'Output the linter results to a file. Defaults to stdout.'),
       ),
       'only-new' => array(
         'param' => 'bool',
         'supports' => array('git', 'hg'), // TODO: svn
         'help' => pht(
           'Display only messages not present in the original code.'),
       ),
       'engine' => array(
         'param' => 'classname',
         'help' => pht('Override configured lint engine for this project.'),
       ),
       'apply-patches' => array(
         'help' => pht(
           'Apply patches suggested by lint to the working copy without '.
           'prompting.'),
         'conflicts' => array(
           'never-apply-patches' => true,
         ),
       ),
       'never-apply-patches' => array(
         'help' => pht('Never apply patches suggested by lint.'),
         'conflicts' => array(
           'apply-patches' => true,
         ),
       ),
       'amend-all' => array(
         'help' => pht(
           'When linting git repositories, amend HEAD with all patches '.
           'suggested by lint without prompting.'),
       ),
       'amend-autofixes' => array(
         'help' => pht(
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.'),
       ),
       'everything' => array(
         'help' => pht('Lint all files in the project.'),
         'conflicts' => array(
           'cache' => pht('%s lints all files', '--everything'),
           'rev' => pht('%s lints all files', '--everything'),
         ),
       ),
       'severity' => array(
         'param' => 'string',
         'help' => pht(
           "Set minimum message severity. One of: %s. Defaults to '%s'.",
           sprintf(
             "'%s'",
             implode(
               "', '",
               array_keys(ArcanistLintSeverity::getLintSeverities()))),
           self::DEFAULT_SEVERITY),
       ),
       'cache' => array(
         'param' => 'bool',
         'help' => pht(
           "%d to disable cache, %d to enable. The default value is determined ".
           "by '%s' in configuration, which defaults to off. See notes in '%s'.",
           0,
           1,
           'arc.lint.cache',
           'arc.lint.cache'),
       ),
       '*' => 'paths',
     );
   }
 
   public function requiresAuthentication() {
     return (bool)$this->getArgument('only-new');
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   private function getCacheKey() {
     return implode("\n", array(
       get_class($this->engine),
       $this->getArgument('severity', self::DEFAULT_SEVERITY),
       $this->shouldLintAll,
     ));
   }
 
   public function run() {
     $console = PhutilConsole::getConsole();
     $working_copy = $this->getWorkingCopy();
     $configuration_manager = $this->getConfigurationManager();
 
     $engine = $this->newLintEngine($this->getArgument('engine'));
 
     $rev = $this->getArgument('rev');
     $paths = $this->getArgument('paths');
     $use_cache = $this->getArgument('cache', null);
     $everything = $this->getArgument('everything');
     if ($everything && $paths) {
       throw new ArcanistUsageException(
         pht(
           'You can not specify paths with %s. The %s flag lints every file.',
           '--everything',
           '--everything'));
     }
     if ($use_cache === null) {
       $use_cache = (bool)$configuration_manager->getConfigFromAnySource(
         'arc.lint.cache',
         false);
     }
 
     if ($rev && $paths) {
       throw new ArcanistUsageException(
         pht('Specify either %s or paths.', '--rev'));
     }
 
 
     // NOTE: When the user specifies paths, we imply --lintall and show all
     // warnings for the paths in question. This is easier to deal with for
     // us and less confusing for users.
     $this->shouldLintAll = $paths ? true : false;
     if ($this->getArgument('lintall')) {
       $this->shouldLintAll = true;
     } else if ($this->getArgument('only-changed')) {
       $this->shouldLintAll = false;
     }
 
     if ($everything) {
-      $paths = iterator_to_array($this->getRepositoryApi()->getAllFiles());
+      $paths = iterator_to_array($this->getRepositoryAPI()->getAllFiles());
       $this->shouldLintAll = true;
     } else {
       $paths = $this->selectPathsForWorkflow($paths, $rev);
     }
 
     $this->engine = $engine;
 
     $engine->setMinimumSeverity(
       $this->getArgument('severity', self::DEFAULT_SEVERITY));
 
     $file_hashes = array();
     if ($use_cache) {
       $engine->setRepositoryVersion($this->getRepositoryVersion());
       $cache = $this->readScratchJSONFile('lint-cache.json');
       $cache = idx($cache, $this->getCacheKey(), array());
       $cached = array();
 
       foreach ($paths as $path) {
         $abs_path = $engine->getFilePathOnDisk($path);
         if (!Filesystem::pathExists($abs_path)) {
           continue;
         }
         $file_hashes[$abs_path] = md5_file($abs_path);
 
         if (!isset($cache[$path])) {
           continue;
         }
         $messages = idx($cache[$path], $file_hashes[$abs_path]);
         if ($messages !== null) {
           $cached[$path] = $messages;
         }
       }
 
       if ($cached) {
         $console->writeErr(
           "%s\n",
           pht(
             "Using lint cache, use '%s' to disable it.",
             '--cache 0'));
       }
 
       $engine->setCachedResults($cached);
     }
 
     // Propagate information about which lines changed to the lint engine.
     // This is used so that the lint engine can drop warning messages
     // concerning lines that weren't in the change.
     $engine->setPaths($paths);
     if (!$this->shouldLintAll) {
       foreach ($paths as $path) {
         // Note that getChangedLines() returns null to indicate that a file
         // is binary or a directory (i.e., changed lines are not relevant).
         $engine->setPathChangedLines(
           $path,
           $this->getChangedLines($path, 'new'));
       }
     }
 
     // Enable possible async linting only for 'arc diff' not 'arc lint'
     if ($this->getParentWorkflow()) {
       $engine->setEnableAsyncLint(true);
     } else {
       $engine->setEnableAsyncLint(false);
     }
 
     if ($this->getArgument('only-new')) {
       $conduit = $this->getConduit();
       $api = $this->getRepositoryAPI();
       if ($rev) {
         $api->setBaseCommit($rev);
       }
       $svn_root = id(new PhutilURI($api->getSourceControlPath()))->getPath();
 
       $all_paths = array();
       foreach ($paths as $path) {
         $path = str_replace(DIRECTORY_SEPARATOR, '/', $path);
         $full_paths = array($path);
 
         $change = $this->getChange($path);
         $type = $change->getType();
         if (ArcanistDiffChangeType::isOldLocationChangeType($type)) {
           $full_paths = $change->getAwayPaths();
         } else if (ArcanistDiffChangeType::isNewLocationChangeType($type)) {
           continue;
         } else if (ArcanistDiffChangeType::isDeleteChangeType($type)) {
           continue;
         }
 
         foreach ($full_paths as $full_path) {
           $all_paths[$svn_root.'/'.$full_path] = $path;
         }
       }
 
       $lint_future = $conduit->callMethod('diffusion.getlintmessages', array(
         'repositoryPHID' => idx($this->loadProjectRepository(), 'phid'),
         'branch' => '', // TODO: Tracking branch.
         'commit' => $api->getBaseCommit(),
         'files' => array_keys($all_paths),
       ));
     }
 
     $failed = null;
     try {
       $engine->run();
     } catch (Exception $ex) {
       $failed = $ex;
     }
 
     $results = $engine->getResults();
 
     if ($this->getArgument('only-new')) {
       $total = 0;
       foreach ($results as $result) {
         $total += count($result->getMessages());
       }
 
       // Don't wait for response with default value of --only-new.
       $timeout = null;
       if ($this->getArgument('only-new') === null || !$total) {
         $timeout = 0;
       }
 
       $raw_messages = $this->resolveCall($lint_future, $timeout);
       if ($raw_messages && $total) {
         $old_messages = array();
         $line_maps = array();
         foreach ($raw_messages as $message) {
           $path = $all_paths[$message['path']];
           $line = $message['line'];
           $code = $message['code'];
 
           if (!isset($line_maps[$path])) {
             $line_maps[$path] = $this->getChange($path)->buildLineMap();
           }
 
           $new_lines = idx($line_maps[$path], $line);
           if (!$new_lines) { // Unmodified lines after last hunk.
             $last_old = ($line_maps[$path] ? last_key($line_maps[$path]) : 0);
             $news = array_filter($line_maps[$path]);
             $last_new = ($news ? last(end($news)) : 0);
             $new_lines = array($line + $last_new - $last_old);
           }
 
           $error = array($code => array(true));
           foreach ($new_lines as $new) {
             if (isset($old_messages[$path][$new])) {
               $old_messages[$path][$new][$code][] = true;
               break;
             }
             $old_messages[$path][$new] = &$error;
           }
           unset($error);
         }
 
         foreach ($results as $result) {
           foreach ($result->getMessages() as $message) {
             $path = str_replace(DIRECTORY_SEPARATOR, '/', $message->getPath());
             $line = $message->getLine();
             $code = $message->getCode();
             if (!empty($old_messages[$path][$line][$code])) {
               $message->setObsolete(true);
               array_pop($old_messages[$path][$line][$code]);
             }
           }
           $result->sortAndFilterMessages();
         }
       }
     }
 
     if ($this->getArgument('never-apply-patches')) {
       $apply_patches = false;
     } else {
       $apply_patches = true;
     }
 
     if ($this->getArgument('apply-patches')) {
       $prompt_patches = false;
     } else {
       $prompt_patches = true;
     }
 
     if ($this->getArgument('amend-all')) {
       $this->shouldAmendChanges = true;
       $this->shouldAmendWithoutPrompt = true;
     }
 
     if ($this->getArgument('amend-autofixes')) {
       $prompt_autofix_patches = false;
       $this->shouldAmendChanges = true;
       $this->shouldAmendAutofixesWithoutPrompt = true;
     } else {
       $prompt_autofix_patches = true;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($this->shouldAmendChanges) {
       $this->shouldAmendChanges = $repository_api->supportsAmend() &&
         !$this->isHistoryImmutable();
     }
 
     $wrote_to_disk = false;
 
     switch ($this->getArgument('output')) {
       case 'json':
         $renderer = new ArcanistJSONLintRenderer();
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         break;
       case 'summary':
         $renderer = new ArcanistSummaryLintRenderer();
         break;
       case 'none':
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         $renderer = new ArcanistNoneLintRenderer();
         break;
       case 'compiler':
         $renderer = new ArcanistCompilerLintRenderer();
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         break;
       case 'xml':
         $renderer = new ArcanistCheckstyleXMLLintRenderer();
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         break;
       default:
         $renderer = new ArcanistConsoleLintRenderer();
         $renderer->setShowAutofixPatches($prompt_autofix_patches);
         break;
     }
 
     $all_autofix = true;
     $tmp = null;
 
     if ($this->getArgument('outfile') !== null) {
       $tmp = id(new TempFile())
         ->setPreserveFile(true);
     }
 
     $preamble = $renderer->renderPreamble();
     if ($tmp) {
       Filesystem::appendFile($tmp, $preamble);
     } else {
       $console->writeOut('%s', $preamble);
     }
 
     foreach ($results as $result) {
       $result_all_autofix = $result->isAllAutofix();
 
       if (!$result->getMessages() && !$result_all_autofix) {
         continue;
       }
 
       if (!$result_all_autofix) {
         $all_autofix = false;
       }
 
       $lint_result = $renderer->renderLintResult($result);
       if ($lint_result) {
         if ($tmp) {
           Filesystem::appendFile($tmp, $lint_result);
         } else {
           $console->writeOut('%s', $lint_result);
         }
       }
 
       if ($apply_patches && $result->isPatchable()) {
         $patcher = ArcanistLintPatcher::newFromArcanistLintResult($result);
         $old_file = $result->getFilePathOnDisk();
 
         if ($prompt_patches &&
             !($result_all_autofix && !$prompt_autofix_patches)) {
           if (!Filesystem::pathExists($old_file)) {
             $old_file = '/dev/null';
           }
           $new_file = new TempFile();
           $new = $patcher->getModifiedFileContent();
           Filesystem::writeFile($new_file, $new);
 
           // TODO: Improve the behavior here, make it more like
           // difference_render().
           list(, $stdout, $stderr) =
             exec_manual('diff -u %s %s', $old_file, $new_file);
           $console->writeOut('%s', $stdout);
           $console->writeErr('%s', $stderr);
 
           $prompt = pht(
             'Apply this patch to %s?',
             phutil_console_format('__%s__', $result->getPath()));
           if (!$console->confirm($prompt, $default = true)) {
             continue;
           }
         }
 
         $patcher->writePatchToDisk();
         $wrote_to_disk = true;
         $file_hashes[$old_file] = md5_file($old_file);
       }
     }
 
     $postamble = $renderer->renderPostamble();
     if ($tmp) {
       Filesystem::appendFile($tmp, $postamble);
       Filesystem::rename($tmp, $this->getArgument('outfile'));
     } else {
       $console->writeOut('%s', $postamble);
     }
 
     if ($wrote_to_disk && $this->shouldAmendChanges) {
       if ($this->shouldAmendWithoutPrompt ||
           ($this->shouldAmendAutofixesWithoutPrompt && $all_autofix)) {
         $console->writeOut(
           "<bg:yellow>** %s **</bg> %s\n",
           pht('LINT NOTICE'),
           pht('Automatically amending HEAD with lint patches.'));
         $amend = true;
       } else {
         $amend = $console->confirm(pht('Amend HEAD with lint patches?'));
       }
 
       if ($amend) {
         if ($repository_api instanceof ArcanistGitAPI) {
           // Add the changes to the index before amending
           $repository_api->execxLocal('add -u');
         }
 
         $repository_api->amendCommit();
       } else {
         throw new ArcanistUsageException(
           pht(
             'Sort out the lint changes that were applied to the working '.
             'copy and relint.'));
       }
     }
 
     if ($this->getArgument('output') == 'json') {
       // NOTE: Required by save_lint.php in Phabricator.
       return 0;
     }
 
     if ($failed) {
       if ($failed instanceof ArcanistNoEffectException) {
         if ($renderer instanceof ArcanistNoneLintRenderer) {
           return 0;
         }
       }
       throw $failed;
     }
 
     $unresolved = array();
     $has_warnings = false;
     $has_errors = false;
 
     foreach ($results as $result) {
       foreach ($result->getMessages() as $message) {
         if (!$message->isPatchApplied()) {
           if ($message->isError()) {
             $has_errors = true;
           } else if ($message->isWarning()) {
             $has_warnings = true;
           }
           $unresolved[] = $message;
         }
       }
     }
     $this->unresolvedMessages = $unresolved;
 
     $cache = $this->readScratchJSONFile('lint-cache.json');
     $cached = idx($cache, $this->getCacheKey(), array());
     if ($cached || $use_cache) {
       $stopped = $engine->getStoppedPaths();
       foreach ($results as $result) {
         $path = $result->getPath();
         if (!$use_cache) {
           unset($cached[$path]);
           continue;
         }
         $abs_path = $engine->getFilePathOnDisk($path);
         if (!Filesystem::pathExists($abs_path)) {
           continue;
         }
         $version = $result->getCacheVersion();
         $cached_path = array();
         if (isset($stopped[$path])) {
           $cached_path['stopped'] = $stopped[$path];
         }
         $cached_path['repository_version'] = $this->getRepositoryVersion();
         foreach ($result->getMessages() as $message) {
           $granularity = $message->getGranularity();
           if ($granularity == ArcanistLinter::GRANULARITY_GLOBAL) {
             continue;
           }
           if (!$message->isPatchApplied()) {
             $cached_path[] = $message->toDictionary();
           }
         }
         $hash = idx($file_hashes, $abs_path);
         if (!$hash) {
           $hash = md5_file($abs_path);
         }
         $cached[$path] = array($hash => array($version => $cached_path));
       }
       $cache[$this->getCacheKey()] = $cached;
       // TODO: Garbage collection.
       $this->writeScratchJSONFile('lint-cache.json', $cache);
     }
 
     // Take the most severe lint message severity and use that
     // as the result code.
     if ($has_errors) {
       $result_code = self::RESULT_ERRORS;
     } else if ($has_warnings) {
       $result_code = self::RESULT_WARNINGS;
     } else {
       $result_code = self::RESULT_OKAY;
     }
 
     if (!$this->getParentWorkflow()) {
       if ($result_code == self::RESULT_OKAY) {
         $console->writeOut('%s', $renderer->renderOkayResult());
       }
     }
 
     return $result_code;
   }
 
   public function getUnresolvedMessages() {
     return $this->unresolvedMessages;
   }
 
 }
diff --git a/src/workflow/ArcanistSetConfigWorkflow.php b/src/workflow/ArcanistSetConfigWorkflow.php
index 9d9b099d..75b4334f 100644
--- a/src/workflow/ArcanistSetConfigWorkflow.php
+++ b/src/workflow/ArcanistSetConfigWorkflow.php
@@ -1,131 +1,146 @@
 <?php
 
 /**
  * Write configuration settings.
  */
 final class ArcanistSetConfigWorkflow extends ArcanistWorkflow {
 
   public function getWorkflowName() {
     return 'set-config';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **set-config** [__options__] -- __name__ __value__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: cli
           Sets an arc configuration option.
 
           Options are either user (apply to all arc commands you invoke
           from the current user) or local (apply only to the current working
           copy). By default, user configuration is written. Use __--local__
           to write local configuration.
 
           User values are written to '~/.arcrc' on Linux and Mac OS X, and an
           undisclosed location on Windows. Local values are written to an arc
           directory under either .git, .hg, or .svn as appropriate.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'local' => array(
         'help' => pht('Set a local config value instead of a user one.'),
       ),
       '*' => 'argv',
     );
   }
 
   public function requiresRepositoryAPI() {
     return $this->getArgument('local');
   }
 
   public function run() {
     $argv = $this->getArgument('argv');
     if (count($argv) != 2) {
       throw new ArcanistUsageException(
         pht('Specify a key and a value.'));
     }
     $configuration_manager = $this->getConfigurationManager();
 
     $is_local = $this->getArgument('local');
 
     if ($is_local) {
       $config = $configuration_manager->readLocalArcConfig();
       $which = 'local';
     } else {
       $config = $configuration_manager->readUserArcConfig();
       $which = 'user';
     }
 
     $key = $argv[0];
     $val = $argv[1];
 
     $settings = new ArcanistSettings();
 
+    $console = PhutilConsole::getConsole();
+
+    if (!$settings->getHelp($key)) {
+      $warning = tsprintf(
+        "**%s:** %s\n",
+        pht('Warning'),
+        pht(
+          'The configuration key "%s" is not recognized by arc. It may '.
+          'be misspelled or out of date.',
+          $key));
+      $console->writeErr('%s', $warning);
+    }
+
     $old = null;
     if (array_key_exists($key, $config)) {
       $old = $config[$key];
     }
 
     if (!strlen($val)) {
       unset($config[$key]);
       if ($is_local) {
         $configuration_manager->writeLocalArcConfig($config);
       } else {
         $configuration_manager->writeUserArcConfig($config);
       }
 
       $old = $settings->formatConfigValueForDisplay($key, $old);
 
       if ($old === null) {
-        echo pht(
-          "Deleted key '%s' from %s config.\n",
+        $message = pht(
+          'Deleted key "%s" from %s config.',
           $key,
           $which);
       } else {
-        echo pht(
-          "Deleted key '%s' from %s config (was %s).\n",
+        $message = pht(
+          'Deleted key "%s" from %s config (was %s).',
           $key,
           $which,
           $old);
       }
+      $console->writeOut('%s', tsprintf("%s\n", $message));
     } else {
       $val = $settings->willWriteValue($key, $val);
 
       $config[$key] = $val;
       if ($is_local) {
         $configuration_manager->writeLocalArcConfig($config);
       } else {
         $configuration_manager->writeUserArcConfig($config);
       }
 
       $val = $settings->formatConfigValueForDisplay($key, $val);
       $old = $settings->formatConfigValueForDisplay($key, $old);
 
       if ($old === null) {
-        echo pht(
-          "Set key '%s' = %s in %s config.\n",
+        $message = pht(
+          'Set key "%s" = %s in %s config.',
           $key,
           $val,
           $which);
       } else {
-        echo pht(
-          "Set key '%s' = %s in %s config (was %s).\n",
+        $message = pht(
+          'Set key "%s" = %s in %s config (was %s).',
           $key,
           $val,
           $which,
           $old);
       }
+      $console->writeOut('%s', tsprintf("%s\n", $message));
     }
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistStartWorkflow.php b/src/workflow/ArcanistStartWorkflow.php
index b940265e..b39cea5a 100644
--- a/src/workflow/ArcanistStartWorkflow.php
+++ b/src/workflow/ArcanistStartWorkflow.php
@@ -1,82 +1,82 @@
 <?php
 
 /**
  * Start time tracking on an object.
  */
 final class ArcanistStartWorkflow extends ArcanistPhrequentWorkflow {
 
   public function getWorkflowName() {
     return 'start';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **start** __object__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Start tracking work in Phrequent.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function getArguments() {
     return array(
       '*' => 'name',
     );
   }
 
   public function run() {
     $conduit = $this->getConduit();
 
     $started_phids = array();
     $short_name = $this->getArgument('name');
 
     foreach ($short_name as $object_name) {
       $object_lookup = $conduit->callMethodSynchronous(
         'phid.lookup',
         array(
           'names' => array($object_name),
         ));
 
       if (!array_key_exists($object_name, $object_lookup)) {
         echo phutil_console_format(
           "%s\n",
           pht("No such object '%s' found.", $object_name));
         return 1;
       }
 
       $object_phid = $object_lookup[$object_name]['phid'];
 
       $started_phids[] = $conduit->callMethodSynchronous(
         'phrequent.push',
         array(
           'objectPHID' => $object_phid,
         ));
     }
 
     $phid_query = $conduit->callMethodSynchronous(
       'phid.query',
       array(
         'phids' => $started_phids,
       ));
 
     echo phutil_console_format(
       "%s:  %s\n\n",
       pht('Started'),
       implode(', ', ipull($phid_query, 'fullName')));
-    $this->printCurrentTracking(true);
+    $this->printCurrentTracking();
   }
 
 }
diff --git a/src/workflow/ArcanistStopWorkflow.php b/src/workflow/ArcanistStopWorkflow.php
index 1e9f2518..2af72edb 100644
--- a/src/workflow/ArcanistStopWorkflow.php
+++ b/src/workflow/ArcanistStopWorkflow.php
@@ -1,111 +1,111 @@
 <?php
 
 /**
  * Stop time tracking on an object.
  */
 final class ArcanistStopWorkflow extends ArcanistPhrequentWorkflow {
 
   public function getWorkflowName() {
     return 'stop';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **stop** [--note __note__] [__objects__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Stop tracking work in Phrequent.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function getArguments() {
     return array(
       'note' => array(
         'param' => 'note',
         'help' => pht('A note to attach to the tracked time.'),
       ),
       '*' => 'name',
     );
   }
 
   public function run() {
     $conduit = $this->getConduit();
     $names = $this->getArgument('name');
 
     $object_lookup = $conduit->callMethodSynchronous(
       'phid.lookup',
       array(
         'names' => $names,
       ));
 
     foreach ($names as $object_name) {
       if (!array_key_exists($object_name, $object_lookup)) {
         throw new ArcanistUsageException(
           pht("No such object '%s' found.", $object_name));
         return 1;
       }
     }
 
     if (count($names) === 0) {
       // Implicit stop; add an entry so the loop will call
       // `phrequent.pop` with a null `objectPHID`.
       $object_lookup[] = array('phid' => null);
     }
 
     $stopped_phids = array();
     foreach ($object_lookup as $ref) {
       $object_phid = $ref['phid'];
 
       $stopped_phid = $conduit->callMethodSynchronous(
         'phrequent.pop',
         array(
           'objectPHID' => $object_phid,
           'note' => $this->getArgument('note'),
         ));
       if ($stopped_phid !== null) {
         $stopped_phids[] = $stopped_phid;
       }
     }
 
     if (count($stopped_phids) === 0) {
       if (count($names) === 0) {
         echo phutil_console_format(
           "%s\n",
           pht('Not currently tracking time against any object.'));
       } else {
         echo phutil_console_format(
           "%s\n",
           pht(
             'Not currently tracking time against %s.',
             implode(', ', ipull($object_lookup, 'fullName'))));
       }
       return 1;
     }
 
     $phid_query = $conduit->callMethodSynchronous(
       'phid.query',
       array(
         'phids' => $stopped_phids,
       ));
 
     echo phutil_console_format(
       "%s  %s\n\n",
       pht('Stopped:'),
       implode(', ', ipull($phid_query, 'fullName')));
-    $this->printCurrentTracking(true);
+    $this->printCurrentTracking();
   }
 
 }
diff --git a/src/workflow/ArcanistTasksWorkflow.php b/src/workflow/ArcanistTasksWorkflow.php
index 95cc7de4..3b9a0789 100644
--- a/src/workflow/ArcanistTasksWorkflow.php
+++ b/src/workflow/ArcanistTasksWorkflow.php
@@ -1,211 +1,211 @@
 <?php
 
 /**
  * Displays User Tasks.
  */
 final class ArcanistTasksWorkflow extends ArcanistWorkflow {
 
   private $tasks;
 
   public function getWorkflowName() {
     return 'tasks';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **tasks** [__options__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
         View all assigned tasks.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return false;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function getArguments() {
     return array(
       'status' => array(
         'param' => 'task_status',
         'help' => pht('Show tasks that are open or closed, default is open.'),
       ),
       'owner' => array(
         'param' => 'username',
         'paramtype' => 'username',
         'help' => pht(
           'Only show tasks assigned to the given username, '.
           'also accepts %s to show all, default is you.',
           '@all'),
         'conflict' => array(
           'unassigned' => pht('%s suppresses unassigned', '--owner'),
         ),
       ),
       'order' => array(
         'param' => 'task_order',
         'help' => pht(
           'Arrange tasks based on priority, created, or modified, '.
           'default is priority.'),
       ),
       'limit' => array(
         'param' => 'n',
         'paramtype' => 'int',
         'help' => pht('Limit the amount of tasks outputted, default is all.'),
       ),
       'unassigned' => array(
         'help' => pht('Only show tasks that are not assigned (upforgrabs).'),
       ),
     );
   }
 
   public function run() {
     $output = array();
 
     $status     = $this->getArgument('status');
     $owner      = $this->getArgument('owner');
     $order      = $this->getArgument('order');
     $limit      = $this->getArgument('limit');
     $unassigned = $this->getArgument('unassigned');
 
     if ($owner) {
-      $owner_phid = $this->findOwnerPhid($owner);
+      $owner_phid = $this->findOwnerPHID($owner);
     } else if ($unassigned) {
       $owner_phid = null;
     } else {
       $owner_phid = $this->getUserPHID();
     }
 
     $this->tasks = $this->loadManiphestTasks(
       ($status == 'all' ? 'any' : $status),
       $owner_phid,
       $order,
       $limit);
 
     if (!$this->tasks) {
       echo pht('No tasks found.')."\n";
       return 0;
     }
 
     $table = id(new PhutilConsoleTable())
       ->setShowHeader(false)
       ->addColumn('id', array('title' => pht('ID')))
       ->addColumn('title', array('title' => pht('Title')))
       ->addColumn('priority', array('title' => pht('Priority')))
       ->addColumn('status', array('title' => pht('Status')));
 
     foreach ($this->tasks as $task) {
       $output = array();
 
       // Render the "T123" column.
       $task_id = 'T'.$task['id'];
       $formatted_task_id = tsprintf('**%s**', $task_id);
       $output['id'] = $formatted_task_id;
 
       // Render the "Title" column.
       $formatted_title = rtrim($task['title']);
       $output['title'] = $formatted_title;
 
       // Render the "Priority" column.
       $web_to_terminal_colors = array(
         'violet'      => 'magenta',
         'indigo'      => 'magenta',
         'orange'      => 'red',
         'sky'         => 'cyan',
         'red'         => 'red',
         'yellow'      => 'yellow',
         'green'       => 'green',
         'blue'        => 'blue',
         'cyan'        => 'cyan',
         'magenta'     => 'magenta',
         'lightred'    => 'red',
         'lightorange' => 'red',
         'lightyellow' => 'yellow',
         'lightgreen'  => 'green',
         'lightblue'   => 'blue',
         'lightsky'    => 'blue',
         'lightindigo' => 'magenta',
         'lightviolet' => 'magenta',
       );
 
       if (isset($task['priorityColor'])) {
         $color = idx($web_to_terminal_colors, $task['priorityColor'], 'white');
       } else {
         $color = 'white';
       }
       $formatted_priority = tsprintf(
         "<bg:{$color}> </bg> %s",
         $task['priority']);
       $output['priority'] = $formatted_priority;
 
       // Render the "Status" column.
       if (isset($task['isClosed'])) {
         if ($task['isClosed']) {
           $status_text = $task['statusName'];
           $status_color = 'red';
         } else {
           $status_text = $task['statusName'];
           $status_color = 'green';
         }
         $formatted_status = tsprintf(
           "<bg:{$status_color}> </bg> %s",
           $status_text);
         $output['status'] = $formatted_status;
       } else {
         $output['status'] = '';
       }
 
       $table->addRow($output);
     }
 
     $table->draw();
   }
 
   private function findOwnerPHID($owner) {
     $conduit = $this->getConduit();
 
     $users = $conduit->callMethodSynchronous(
       'user.query',
       array(
         'usernames' => array($owner),
       ));
 
     if (!$users) {
       return null;
     }
 
     $user = head($users);
     return idx($user, 'phid');
   }
 
   private function loadManiphestTasks($status, $owner_phid, $order, $limit) {
     $conduit = $this->getConduit();
 
     $find_params = array();
     if ($owner_phid !== null) {
       $find_params['ownerPHIDs'] = array($owner_phid);
     }
 
     if ($limit !== false) {
       $find_params['limit'] = $limit;
     }
 
     $find_params['order'] = ($order ? 'order-'.$order : 'order-priority');
     $find_params['status'] = ($status ? 'status-'.$status : 'status-open');
 
     return $conduit->callMethodSynchronous('maniphest.query', $find_params);
   }
 
 }
diff --git a/src/workflow/ArcanistUnitWorkflow.php b/src/workflow/ArcanistUnitWorkflow.php
index a1aadd3b..00ef8a59 100644
--- a/src/workflow/ArcanistUnitWorkflow.php
+++ b/src/workflow/ArcanistUnitWorkflow.php
@@ -1,427 +1,427 @@
 <?php
 
 /**
  * Runs unit tests which cover your changes.
  */
 final class ArcanistUnitWorkflow extends ArcanistWorkflow {
 
   const RESULT_OKAY      = 0;
   const RESULT_UNSOUND   = 1;
   const RESULT_FAIL      = 2;
   const RESULT_SKIP      = 3;
 
   private $unresolvedTests;
   private $testResults;
   private $engine;
 
   public function getWorkflowName() {
     return 'unit';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **unit** [__options__] [__paths__]
       **unit** [__options__] --rev [__rev__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Run unit tests that cover specified paths. If no paths are specified,
           unit tests covering all modified files will be run.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'rev' => array(
         'param' => 'revision',
         'help' => pht(
           'Run unit tests covering changes since a specific revision.'),
         'supports' => array(
           'git',
           'hg',
         ),
         'nosupport' => array(
           'svn' => pht(
             'Arc unit does not currently support %s in SVN.',
             '--rev'),
         ),
       ),
       'engine' => array(
         'param' => 'classname',
         'help' => pht('Override configured unit engine for this project.'),
       ),
       'coverage' => array(
         'help' => pht('Always enable coverage information.'),
         'conflicts' => array(
           'no-coverage' => null,
         ),
       ),
       'no-coverage' => array(
         'help' => pht('Always disable coverage information.'),
       ),
       'detailed-coverage' => array(
         'help' => pht(
           'Show a detailed coverage report on the CLI. Implies %s.',
           '--coverage'),
       ),
       'json' => array(
         'help' => pht('Report results in JSON format.'),
       ),
       'output' => array(
         'param' => 'format',
         'help' => pht(
           "With 'full', show full pretty report (Default). ".
           "With 'json', report results in JSON format. ".
           "With 'ugly', use uglier (but more efficient) JSON formatting. ".
           "With 'none', don't print results."),
         'conflicts' => array(
           'json' => pht('Only one output format allowed'),
           'ugly' => pht('Only one output format allowed'),
         ),
       ),
       'target' => array(
         'param' => 'phid',
         'help' => pht(
           '(PROTOTYPE) Record a copy of the test results on the specified '.
           'Harbormaster build target.'),
       ),
       'everything' => array(
         'help' => pht('Run every test.'),
         'conflicts' => array(
           'rev' => pht('%s runs all tests.', '--everything'),
         ),
       ),
       'ugly' => array(
         'help' => pht(
           'With %s, use uglier (but more efficient) formatting.',
           '--json'),
       ),
       '*' => 'paths',
     );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresConduit() {
     return $this->shouldUploadResults();
   }
 
   public function requiresAuthentication() {
     return $this->shouldUploadResults();
   }
 
   public function getEngine() {
     return $this->engine;
   }
 
   public function run() {
     $working_copy = $this->getWorkingCopy();
 
     $paths = $this->getArgument('paths');
     $rev = $this->getArgument('rev');
     $everything = $this->getArgument('everything');
     if ($everything && $paths) {
       throw new ArcanistUsageException(
         pht(
           'You can not specify paths with %s. The %s flag runs every test.',
           '--everything',
           '--everything'));
     }
 
     if ($everything) {
-      $paths = iterator_to_array($this->getRepositoryApi()->getAllFiles());
+      $paths = iterator_to_array($this->getRepositoryAPI()->getAllFiles());
     } else {
       $paths = $this->selectPathsForWorkflow($paths, $rev);
     }
 
     $this->engine = $this->newUnitTestEngine($this->getArgument('engine'));
     if ($everything) {
       $this->engine->setRunAllTests(true);
     } else {
       $this->engine->setPaths($paths);
     }
 
     $renderer = new ArcanistUnitConsoleRenderer();
     $this->engine->setRenderer($renderer);
 
     $enable_coverage = null; // Means "default".
     if ($this->getArgument('coverage') ||
         $this->getArgument('detailed-coverage')) {
       $enable_coverage = true;
     } else if ($this->getArgument('no-coverage')) {
       $enable_coverage = false;
     }
     $this->engine->setEnableCoverage($enable_coverage);
 
     $results = $this->engine->run();
 
     $this->validateUnitEngineResults($this->engine, $results);
 
     $this->testResults = $results;
 
     $console = PhutilConsole::getConsole();
 
     $output_format = $this->getOutputFormat();
 
     if ($output_format !== 'full') {
       $console->disableOut();
     }
 
     $unresolved = array();
     $coverage = array();
     foreach ($results as $result) {
       $result_code = $result->getResult();
       if ($this->engine->shouldEchoTestResults()) {
         $console->writeOut('%s', $renderer->renderUnitResult($result));
       }
       if ($result_code != ArcanistUnitTestResult::RESULT_PASS) {
         $unresolved[] = $result;
       }
       if ($result->getCoverage()) {
         foreach ($result->getCoverage() as $file => $report) {
           $coverage[$file][] = $report;
         }
       }
     }
 
     if ($coverage) {
       $file_coverage = array_fill_keys(
         $paths,
         0);
       $file_reports = array();
       foreach ($coverage as $file => $reports) {
         $report = ArcanistUnitTestResult::mergeCoverage($reports);
         $cov = substr_count($report, 'C');
         $uncov = substr_count($report, 'U');
         if ($cov + $uncov) {
           $coverage = $cov / ($cov + $uncov);
         } else {
           $coverage = 0;
         }
         $file_coverage[$file] = $coverage;
         $file_reports[$file] = $report;
       }
       $console->writeOut("\n__%s__\n", pht('COVERAGE REPORT'));
 
       asort($file_coverage);
       foreach ($file_coverage as $file => $coverage) {
         $console->writeOut(
           "    **%s%%**     %s\n",
           sprintf('% 3d', (int)(100 * $coverage)),
           $file);
 
         $full_path = $working_copy->getProjectRoot().'/'.$file;
         if ($this->getArgument('detailed-coverage') &&
             Filesystem::pathExists($full_path) &&
             is_file($full_path) &&
             array_key_exists($file, $file_reports)) {
           $console->writeOut(
             '%s',
             $this->renderDetailedCoverageReport(
               Filesystem::readFile($full_path),
               $file_reports[$file]));
         }
       }
     }
 
     $this->unresolvedTests = $unresolved;
 
     $overall_result = self::RESULT_OKAY;
     foreach ($results as $result) {
       $result_code = $result->getResult();
       if ($result_code == ArcanistUnitTestResult::RESULT_FAIL ||
           $result_code == ArcanistUnitTestResult::RESULT_BROKEN) {
         $overall_result = self::RESULT_FAIL;
         break;
       } else if ($result_code == ArcanistUnitTestResult::RESULT_UNSOUND) {
         $overall_result = self::RESULT_UNSOUND;
       }
     }
 
     if ($output_format !== 'full') {
       $console->enableOut();
     }
     $data = array_values(mpull($results, 'toDictionary'));
     switch ($output_format) {
       case 'ugly':
         $console->writeOut('%s', json_encode($data));
         break;
       case 'json':
         $json = new PhutilJSON();
         $console->writeOut('%s', $json->encodeFormatted($data));
         break;
       case 'full':
         // already printed
         break;
       case 'none':
         // do nothing
         break;
     }
 
 
     $target_phid = $this->getArgument('target');
     if ($target_phid) {
       $this->uploadTestResults($target_phid, $overall_result, $results);
     }
 
     return $overall_result;
   }
 
   public function getUnresolvedTests() {
     return $this->unresolvedTests;
   }
 
   public function getTestResults() {
     return $this->testResults;
   }
 
   private function renderDetailedCoverageReport($data, $report) {
     $data = explode("\n", $data);
 
     $out = '';
 
     $n = 0;
     foreach ($data as $line) {
       $out .= sprintf('% 5d  ', $n + 1);
       $line = str_pad($line, 80, ' ');
       if (empty($report[$n])) {
         $c = 'N';
       } else {
         $c = $report[$n];
       }
       switch ($c) {
         case 'C':
           $out .= phutil_console_format(
             '<bg:green> %s </bg>',
             $line);
           break;
         case 'U':
           $out .= phutil_console_format(
             '<bg:red> %s </bg>',
             $line);
           break;
         case 'X':
           $out .= phutil_console_format(
             '<bg:magenta> %s </bg>',
             $line);
           break;
         default:
           $out .= ' '.$line.' ';
           break;
       }
       $out .= "\n";
       $n++;
     }
 
     return $out;
   }
 
   private function getOutputFormat() {
     if ($this->getArgument('ugly')) {
       return 'ugly';
     }
     if ($this->getArgument('json')) {
       return 'json';
     }
     $format = $this->getArgument('output');
     $known_formats = array(
       'none' => 'none',
       'json' => 'json',
       'ugly' => 'ugly',
       'full' => 'full',
     );
     return idx($known_formats, $format, 'full');
   }
 
 
   /**
    * Raise a tailored error when a unit test engine returns results in an
    * invalid format.
    *
    * @param ArcanistUnitTestEngine The engine.
    * @param wild Results from the engine.
    */
   private function validateUnitEngineResults(
     ArcanistUnitTestEngine $engine,
     $results) {
 
     if (!is_array($results)) {
       throw new Exception(
         pht(
           'Unit test engine (of class "%s") returned invalid results when '.
           'run (with method "%s"). Expected a list of "%s" objects as results.',
           get_class($engine),
           'run()',
           'ArcanistUnitTestResult'));
     }
 
     foreach ($results as $key => $result) {
       if (!($result instanceof ArcanistUnitTestResult)) {
         throw new Exception(
           pht(
             'Unit test engine (of class "%s") returned invalid results when '.
             'run (with method "%s"). Expected a list of "%s" objects as '.
             'results, but value with key "%s" is not valid.',
             get_class($engine),
             'run()',
             'ArcanistUnitTestResult',
             $key));
       }
     }
 
   }
 
   public static function getHarbormasterTypeFromResult($unit_result) {
     switch ($unit_result) {
       case self::RESULT_OKAY:
       case self::RESULT_SKIP:
         $type = 'pass';
         break;
       default:
         $type = 'fail';
         break;
     }
 
     return $type;
   }
 
   private function shouldUploadResults() {
     return ($this->getArgument('target') !== null);
   }
 
   private function uploadTestResults(
     $target_phid,
     $unit_result,
     array $unit) {
 
     // TODO: It would eventually be nice to stream test results up to the
     // server as we go, but just get things working for now.
 
     $message_type = self::getHarbormasterTypeFromResult($unit_result);
 
     foreach ($unit as $key => $result) {
       $dictionary = $result->toDictionary();
       $unit[$key] = $this->getModernUnitDictionary($dictionary);
     }
 
     $this->getConduit()->callMethodSynchronous(
       'harbormaster.sendmessage',
       array(
         'buildTargetPHID' => $target_phid,
         'unit' => array_values($unit),
         'type' => $message_type,
       ));
   }
 
 }
diff --git a/src/workflow/ArcanistWorkflow.php b/src/workflow/ArcanistWorkflow.php
index 2365083a..192cf243 100644
--- a/src/workflow/ArcanistWorkflow.php
+++ b/src/workflow/ArcanistWorkflow.php
@@ -1,2074 +1,2072 @@
 <?php
 
 /**
  * Implements a runnable command, like "arc diff" or "arc help".
  *
  * = Managing Conduit =
  *
  * Workflows have the builtin ability to open a Conduit connection to a
  * Phabricator installation, so methods can be invoked over the API. Workflows
  * may either not need this (e.g., "help"), or may need a Conduit but not
  * authentication (e.g., calling only public APIs), or may need a Conduit and
  * authentication (e.g., "arc diff").
  *
  * To specify that you need an //unauthenticated// conduit, override
  * @{method:requiresConduit} to return ##true##. To specify that you need an
  * //authenticated// conduit, override @{method:requiresAuthentication} to
  * return ##true##. You can also manually invoke @{method:establishConduit}
  * and/or @{method:authenticateConduit} later in a workflow to upgrade it.
  * Once a conduit is open, you can access the client by calling
  * @{method:getConduit}, which allows you to invoke methods. You can get
  * verified information about the user identity by calling @{method:getUserPHID}
  * or @{method:getUserName} after authentication occurs.
  *
  * = Scratch Files =
  *
  * Arcanist workflows can read and write 'scratch files', which are temporary
  * files stored in the project that persist across commands. They can be useful
  * if you want to save some state, or keep a copy of a long message the user
  * entered if something goes wrong.
  *
  *
  * @task  conduit   Conduit
  * @task  scratch   Scratch Files
  * @task  phabrep   Phabricator Repositories
  */
 abstract class ArcanistWorkflow extends Phobject {
 
   const COMMIT_DISABLE = 0;
   const COMMIT_ALLOW = 1;
   const COMMIT_ENABLE = 2;
 
   private $commitMode = self::COMMIT_DISABLE;
 
   private $conduit;
   private $conduitURI;
   private $conduitCredentials;
   private $conduitAuthenticated;
   private $forcedConduitVersion;
   private $conduitTimeout;
 
   private $userPHID;
   private $userName;
   private $repositoryAPI;
   private $configurationManager;
   private $arguments = array();
   private $passedArguments = array();
   private $command;
 
   private $stashed;
   private $shouldAmend;
 
   private $projectInfo;
   private $repositoryInfo;
   private $repositoryReasons;
 
   private $arcanistConfiguration;
   private $parentWorkflow;
   private $workingDirectory;
   private $repositoryVersion;
 
   private $changeCache = array();
 
 
   public function __construct() {}
 
 
   abstract public function run();
 
   /**
    * Finalizes any cleanup operations that need to occur regardless of
    * whether the command succeeded or failed.
    */
   public function finalize() {
     $this->finalizeWorkingCopy();
   }
 
   /**
    * Return the command used to invoke this workflow from the command like,
    * e.g. "help" for @{class:ArcanistHelpWorkflow}.
    *
    * @return string   The command a user types to invoke this workflow.
    */
   abstract public function getWorkflowName();
 
   /**
    * Return console formatted string with all command synopses.
    *
    * @return string  6-space indented list of available command synopses.
    */
   abstract public function getCommandSynopses();
 
   /**
    * Return console formatted string with command help printed in `arc help`.
    *
    * @return string  10-space indented help to use the command.
    */
   abstract public function getCommandHelp();
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Set the URI which the workflow will open a conduit connection to when
    * @{method:establishConduit} is called. Arcanist makes an effort to set
    * this by default for all workflows (by reading ##.arcconfig## and/or the
    * value of ##--conduit-uri##) even if they don't need Conduit, so a workflow
    * can generally upgrade into a conduit workflow later by just calling
    * @{method:establishConduit}.
    *
    * You generally should not need to call this method unless you are
    * specifically overriding the default URI. It is normally sufficient to
    * just invoke @{method:establishConduit}.
    *
    * NOTE: You can not call this after a conduit has been established.
    *
    * @param string  The URI to open a conduit to when @{method:establishConduit}
    *                is called.
    * @return this
    * @task conduit
    */
   final public function setConduitURI($conduit_uri) {
     if ($this->conduit) {
       throw new Exception(
         pht(
           'You can not change the Conduit URI after a '.
           'conduit is already open.'));
     }
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   /**
    * Returns the URI the conduit connection within the workflow uses.
    *
    * @return string
    * @task conduit
    */
   final public function getConduitURI() {
     return $this->conduitURI;
   }
 
   /**
    * Open a conduit channel to the server which was previously configured by
    * calling @{method:setConduitURI}. Arcanist will do this automatically if
    * the workflow returns ##true## from @{method:requiresConduit}, or you can
    * later upgrade a workflow and build a conduit by invoking it manually.
    *
    * You must establish a conduit before you can make conduit calls.
    *
    * NOTE: You must call @{method:setConduitURI} before you can call this
    * method.
    *
    * @return this
    * @task conduit
    */
   final public function establishConduit() {
     if ($this->conduit) {
       return $this;
     }
 
     if (!$this->conduitURI) {
       throw new Exception(
         pht(
           'You must specify a Conduit URI with %s before you can '.
           'establish a conduit.',
           'setConduitURI()'));
     }
 
     $this->conduit = new ConduitClient($this->conduitURI);
 
     if ($this->conduitTimeout) {
       $this->conduit->setTimeout($this->conduitTimeout);
     }
 
     $user = $this->getConfigFromAnySource('http.basicauth.user');
     $pass = $this->getConfigFromAnySource('http.basicauth.pass');
     if ($user !== null && $pass !== null) {
       $this->conduit->setBasicAuthCredentials($user, $pass);
     }
 
     return $this;
   }
 
   final public function getConfigFromAnySource($key) {
     return $this->configurationManager->getConfigFromAnySource($key);
   }
 
 
   /**
    * Set credentials which will be used to authenticate against Conduit. These
    * credentials can then be used to establish an authenticated connection to
    * conduit by calling @{method:authenticateConduit}. Arcanist sets some
    * defaults for all workflows regardless of whether or not they return true
    * from @{method:requireAuthentication}, based on the ##~/.arcrc## and
    * ##.arcconf## files if they are present. Thus, you can generally upgrade a
    * workflow which does not require authentication into an authenticated
    * workflow by later invoking @{method:requireAuthentication}. You should not
    * normally need to call this method unless you are specifically overriding
    * the defaults.
    *
    * NOTE: You can not call this method after calling
    * @{method:authenticateConduit}.
    *
    * @param dict  A credential dictionary, see @{method:authenticateConduit}.
    * @return this
    * @task conduit
    */
   final public function setConduitCredentials(array $credentials) {
     if ($this->isConduitAuthenticated()) {
       throw new Exception(
         pht('You may not set new credentials after authenticating conduit.'));
     }
 
     $this->conduitCredentials = $credentials;
     return $this;
   }
 
 
   /**
    * Force arc to identify with a specific Conduit version during the
    * protocol handshake. This is primarily useful for development (especially
    * for sending diffs which bump the client Conduit version), since the client
    * still actually speaks the builtin version of the protocol.
    *
    * Controlled by the --conduit-version flag.
    *
    * @param int Version the client should pretend to be.
    * @return this
    * @task conduit
    */
   final public function forceConduitVersion($version) {
     $this->forcedConduitVersion = $version;
     return $this;
   }
 
 
   /**
    * Get the protocol version the client should identify with.
    *
    * @return int Version the client should claim to be.
    * @task conduit
    */
   final public function getConduitVersion() {
     return nonempty($this->forcedConduitVersion, 6);
   }
 
 
   /**
    * Override the default timeout for Conduit.
    *
    * Controlled by the --conduit-timeout flag.
    *
    * @param float Timeout, in seconds.
    * @return this
    * @task conduit
    */
   final public function setConduitTimeout($timeout) {
     $this->conduitTimeout = $timeout;
     if ($this->conduit) {
       $this->conduit->setConduitTimeout($timeout);
     }
     return $this;
   }
 
 
   /**
    * Open and authenticate a conduit connection to a Phabricator server using
    * provided credentials. Normally, Arcanist does this for you automatically
    * when you return true from @{method:requiresAuthentication}, but you can
    * also upgrade an existing workflow to one with an authenticated conduit
    * by invoking this method manually.
    *
    * You must authenticate the conduit before you can make authenticated conduit
    * calls (almost all calls require authentication).
    *
    * This method uses credentials provided via @{method:setConduitCredentials}
    * to authenticate to the server:
    *
    *    - ##user## (required) The username to authenticate with.
    *    - ##certificate## (required) The Conduit certificate to use.
    *    - ##description## (optional) Description of the invoking command.
    *
    * Successful authentication allows you to call @{method:getUserPHID} and
    * @{method:getUserName}, as well as use the client you access with
    * @{method:getConduit} to make authenticated calls.
    *
    * NOTE: You must call @{method:setConduitURI} and
    * @{method:setConduitCredentials} before you invoke this method.
    *
    * @return this
    * @task conduit
    */
   final public function authenticateConduit() {
     if ($this->isConduitAuthenticated()) {
       return $this;
     }
 
     $this->establishConduit();
     $credentials = $this->conduitCredentials;
 
     try {
       if (!$credentials) {
         throw new Exception(
           pht(
             'Set conduit credentials with %s before authenticating conduit!',
             'setConduitCredentials()'));
       }
 
       // If we have `token`, this server supports the simpler, new-style
       // token-based authentication. Use that instead of all the certificate
       // stuff.
       $token = idx($credentials, 'token');
       if (strlen($token)) {
         $conduit = $this->getConduit();
 
         $conduit->setConduitToken($token);
 
         try {
           $result = $this->getConduit()->callMethodSynchronous(
             'user.whoami',
             array());
 
           $this->userName = $result['userName'];
           $this->userPHID = $result['phid'];
 
           $this->conduitAuthenticated = true;
 
           return;
         } catch (Exception $ex) {
           $conduit->setConduitToken(null);
           throw $ex;
         }
       }
 
       if (empty($credentials['user'])) {
         throw new ConduitClientException(
           'ERR-INVALID-USER',
           pht('Empty user in credentials.'));
       }
       if (empty($credentials['certificate'])) {
         throw new ConduitClientException(
           'ERR-NO-CERTIFICATE',
           pht('Empty certificate in credentials.'));
       }
 
       $description = idx($credentials, 'description', '');
       $user        = $credentials['user'];
       $certificate = $credentials['certificate'];
 
       $connection = $this->getConduit()->callMethodSynchronous(
         'conduit.connect',
         array(
           'client'              => 'arc',
           'clientVersion'       => $this->getConduitVersion(),
           'clientDescription'   => php_uname('n').':'.$description,
           'user'                => $user,
           'certificate'         => $certificate,
           'host'                => $this->conduitURI,
         ));
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-NO-CERTIFICATE' ||
           $ex->getErrorCode() == 'ERR-INVALID-USER' ||
           $ex->getErrorCode() == 'ERR-INVALID-AUTH') {
         $conduit_uri = $this->conduitURI;
         $message = phutil_console_format(
           "\n%s\n\n    %s\n\n%s\n%s",
           pht('YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR'),
           pht('To do this, run: **%s**', 'arc install-certificate'),
           pht("The server '%s' rejected your request:", $conduit_uri),
           $ex->getMessage());
         throw new ArcanistUsageException($message);
       } else if ($ex->getErrorCode() == 'NEW-ARC-VERSION') {
 
         // Cleverly disguise this as being AWESOME!!!
 
         echo phutil_console_format("**%s**\n\n", pht('New Version Available!'));
         echo phutil_console_wrap($ex->getMessage());
         echo "\n\n";
         echo pht('In most cases, arc can be upgraded automatically.')."\n";
 
         $ok = phutil_console_confirm(
           pht('Upgrade arc now?'),
           $default_no = false);
         if (!$ok) {
           throw $ex;
         }
 
         $root = dirname(phutil_get_library_root('arcanist'));
 
         chdir($root);
         $err = phutil_passthru('%s upgrade', $root.'/bin/arc');
         if (!$err) {
           echo "\n".pht('Try running your arc command again.')."\n";
         }
         exit(1);
       } else {
         throw $ex;
       }
     }
 
     $this->userName = $user;
     $this->userPHID = $connection['userPHID'];
 
     $this->conduitAuthenticated = true;
 
     return $this;
   }
 
   /**
    * @return bool True if conduit is authenticated, false otherwise.
    * @task conduit
    */
   final protected function isConduitAuthenticated() {
     return (bool)$this->conduitAuthenticated;
   }
 
 
   /**
    * Override this to return true if your workflow requires a conduit channel.
    * Arc will build the channel for you before your workflow executes. This
    * implies that you only need an unauthenticated channel; if you need
    * authentication, override @{method:requiresAuthentication}.
    *
    * @return bool True if arc should build a conduit channel before running
    *              the workflow.
    * @task conduit
    */
   public function requiresConduit() {
     return false;
   }
 
 
   /**
    * Override this to return true if your workflow requires an authenticated
    * conduit channel. This implies that it requires a conduit. Arc will build
    * and authenticate the channel for you before the workflow executes.
    *
    * @return bool True if arc should build an authenticated conduit channel
    *              before running the workflow.
    * @task conduit
    */
   public function requiresAuthentication() {
     return false;
   }
 
 
   /**
    * Returns the PHID for the user once they've authenticated via Conduit.
    *
    * @return phid Authenticated user PHID.
    * @task conduit
    */
   final public function getUserPHID() {
     if (!$this->userPHID) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires authentication, override ".
           "%s to return true.",
           $workflow,
           'requiresAuthentication()'));
     }
     return $this->userPHID;
   }
 
   /**
    * Return the username for the user once they've authenticated via Conduit.
    *
    * @return string Authenticated username.
    * @task conduit
    */
   final public function getUserName() {
     return $this->userName;
   }
 
 
   /**
    * Get the established @{class@libphutil:ConduitClient} in order to make
    * Conduit method calls. Before the client is available it must be connected,
    * either implicitly by making @{method:requireConduit} or
    * @{method:requireAuthentication} return true, or explicitly by calling
    * @{method:establishConduit} or @{method:authenticateConduit}.
    *
    * @return @{class@libphutil:ConduitClient} Live conduit client.
    * @task conduit
    */
   final public function getConduit() {
     if (!$this->conduit) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Conduit, override ".
           "%s to return true.",
           $workflow,
           'requiresConduit()'));
     }
     return $this->conduit;
   }
 
 
   final public function setArcanistConfiguration(
     ArcanistConfiguration $arcanist_configuration) {
 
     $this->arcanistConfiguration = $arcanist_configuration;
     return $this;
   }
 
   final public function getArcanistConfiguration() {
     return $this->arcanistConfiguration;
   }
 
   final public function setConfigurationManager(
     ArcanistConfigurationManager $arcanist_configuration_manager) {
 
     $this->configurationManager = $arcanist_configuration_manager;
     return $this;
   }
 
   final public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
   public function desiresWorkingCopy() {
     return false;
   }
 
   public function requiresRepositoryAPI() {
     return false;
   }
 
   public function desiresRepositoryAPI() {
     return false;
   }
 
   final public function setCommand($command) {
     $this->command = $command;
     return $this;
   }
 
   final public function getCommand() {
     return $this->command;
   }
 
   public function getArguments() {
     return array();
   }
 
   final public function setWorkingDirectory($working_directory) {
     $this->workingDirectory = $working_directory;
     return $this;
   }
 
   final public function getWorkingDirectory() {
     return $this->workingDirectory;
   }
 
   final private function setParentWorkflow($parent_workflow) {
     $this->parentWorkflow = $parent_workflow;
     return $this;
   }
 
   final protected function getParentWorkflow() {
     return $this->parentWorkflow;
   }
 
   final public function buildChildWorkflow($command, array $argv) {
     $arc_config = $this->getArcanistConfiguration();
     $workflow = $arc_config->buildWorkflow($command);
     $workflow->setParentWorkflow($this);
     $workflow->setCommand($command);
     $workflow->setConfigurationManager($this->getConfigurationManager());
 
     if ($this->repositoryAPI) {
       $workflow->setRepositoryAPI($this->repositoryAPI);
     }
 
     if ($this->userPHID) {
       $workflow->userPHID = $this->getUserPHID();
       $workflow->userName = $this->getUserName();
     }
 
     if ($this->conduit) {
       $workflow->conduit = $this->conduit;
       $workflow->setConduitCredentials($this->conduitCredentials);
       $workflow->conduitAuthenticated = $this->conduitAuthenticated;
     }
 
     $workflow->setArcanistConfiguration($arc_config);
 
     $workflow->parseArguments(array_values($argv));
 
     return $workflow;
   }
 
   final public function getArgument($key, $default = null) {
     return idx($this->arguments, $key, $default);
   }
 
   final public function getPassedArguments() {
     return $this->passedArguments;
   }
 
   final public function getCompleteArgumentSpecification() {
     $spec = $this->getArguments();
     $arc_config = $this->getArcanistConfiguration();
     $command = $this->getCommand();
     $spec += $arc_config->getCustomArgumentsForCommand($command);
 
     return $spec;
   }
 
   final public function parseArguments(array $args) {
     $this->passedArguments = $args;
 
     $spec = $this->getCompleteArgumentSpecification();
 
     $dict = array();
 
     $more_key = null;
     if (!empty($spec['*'])) {
       $more_key = $spec['*'];
       unset($spec['*']);
       $dict[$more_key] = array();
     }
 
     $short_to_long_map = array();
     foreach ($spec as $long => $options) {
       if (!empty($options['short'])) {
         $short_to_long_map[$options['short']] = $long;
       }
     }
 
     foreach ($spec as $long => $options) {
       if (!empty($options['repeat'])) {
         $dict[$long] = array();
       }
     }
 
     $more = array();
     $size = count($args);
     for ($ii = 0; $ii < $size; $ii++) {
       $arg = $args[$ii];
       $arg_name = null;
       $arg_key = null;
       if ($arg == '--') {
         $more = array_merge(
           $more,
           array_slice($args, $ii + 1));
         break;
       } else if (!strncmp($arg, '--', 2)) {
         $arg_key = substr($arg, 2);
         $parts = explode('=', $arg_key, 2);
         if (count($parts) == 2) {
           list($arg_key, $val) = $parts;
 
           array_splice($args, $ii, 1, array('--'.$arg_key, $val));
           $size++;
         }
 
         if (!array_key_exists($arg_key, $spec)) {
           $corrected = PhutilArgumentSpellingCorrector::newFlagCorrector()
             ->correctSpelling($arg_key, array_keys($spec));
           if (count($corrected) == 1) {
             PhutilConsole::getConsole()->writeErr(
               pht(
                 "(Assuming '%s' is the British spelling of '%s'.)",
                 '--'.$arg_key,
                 '--'.head($corrected))."\n");
             $arg_key = head($corrected);
           } else {
             throw new ArcanistUsageException(
               pht(
                 "Unknown argument '%s'. Try '%s'.",
                 $arg_key,
                 'arc help'));
           }
         }
       } else if (!strncmp($arg, '-', 1)) {
         $arg_key = substr($arg, 1);
         if (empty($short_to_long_map[$arg_key])) {
           throw new ArcanistUsageException(
             pht(
               "Unknown argument '%s'. Try '%s'.",
               $arg_key,
               'arc help'));
         }
         $arg_key = $short_to_long_map[$arg_key];
       } else {
         $more[] = $arg;
         continue;
       }
 
       $options = $spec[$arg_key];
       if (empty($options['param'])) {
         $dict[$arg_key] = true;
       } else {
         if ($ii == $size - 1) {
           throw new ArcanistUsageException(
             pht(
               "Option '%s' requires a parameter.",
               $arg));
         }
         if (!empty($options['repeat'])) {
           $dict[$arg_key][] = $args[$ii + 1];
         } else {
           $dict[$arg_key] = $args[$ii + 1];
         }
         $ii++;
       }
     }
 
     if ($more) {
       if ($more_key) {
         $dict[$more_key] = $more;
       } else {
         $example = reset($more);
         throw new ArcanistUsageException(
           pht(
             "Unrecognized argument '%s'. Try '%s'.",
             $example,
             'arc help'));
       }
     }
 
     foreach ($dict as $key => $value) {
       if (empty($spec[$key]['conflicts'])) {
         continue;
       }
       foreach ($spec[$key]['conflicts'] as $conflict => $more) {
         if (isset($dict[$conflict])) {
           if ($more) {
             $more = ': '.$more;
           } else {
             $more = '.';
           }
           // TODO: We'll always display these as long-form, when the user might
           // have typed them as short form.
           throw new ArcanistUsageException(
             pht(
               "Arguments '%s' and '%s' are mutually exclusive",
               "--{$key}",
               "--{$conflict}").$more);
         }
       }
     }
 
     $this->arguments = $dict;
 
     $this->didParseArguments();
 
     return $this;
   }
 
   protected function didParseArguments() {
     // Override this to customize workflow argument behavior.
   }
 
   final public function getWorkingCopy() {
     $working_copy = $this->getConfigurationManager()->getWorkingCopyIdentity();
     if (!$working_copy) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a working copy, override ".
           "%s to return true.",
           $workflow,
           'requiresWorkingCopy()'));
     }
     return $working_copy;
   }
 
   final public function setRepositoryAPI($api) {
     $this->repositoryAPI = $api;
     return $this;
   }
 
   final public function hasRepositoryAPI() {
     try {
       return (bool)$this->getRepositoryAPI();
     } catch (Exception $ex) {
       return false;
     }
   }
 
   final public function getRepositoryAPI() {
     if (!$this->repositoryAPI) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Repository API, override ".
           "%s to return true.",
           $workflow,
           'requiresRepositoryAPI()'));
     }
     return $this->repositoryAPI;
   }
 
   final protected function shouldRequireCleanUntrackedFiles() {
     return empty($this->arguments['allow-untracked']);
   }
 
   final public function setCommitMode($mode) {
     $this->commitMode = $mode;
     return $this;
   }
 
   final public function finalizeWorkingCopy() {
     if ($this->stashed) {
       $api = $this->getRepositoryAPI();
       $api->unstashChanges();
       echo pht('Restored stashed changes to the working directory.')."\n";
     }
   }
 
   final public function requireCleanWorkingCopy() {
     $api = $this->getRepositoryAPI();
 
     $must_commit = array();
 
     $working_copy_desc = phutil_console_format(
       "  %s: __%s__\n\n",
       pht('Working copy'),
       $api->getPath());
 
     // NOTE: this is a subversion-only concept.
     $incomplete = $api->getIncompleteChanges();
     if ($incomplete) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n\n%s",
           pht(
             "You have incompletely checked out directories in this working ".
             "copy. Fix them before proceeding.'"),
           $working_copy_desc,
           pht('Incomplete directories in working copy:'),
           implode("\n    ", $incomplete),
           pht(
             "You can fix these paths by running '%s' on them.",
             'svn update')));
     }
 
     $conflicts = $api->getMergeConflicts();
     if ($conflicts) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s",
           pht(
             'You have merge conflicts in this working copy. Resolve merge '.
             'conflicts before proceeding.'),
           $working_copy_desc,
           pht('Conflicts in working copy:'),
           implode("\n    ", $conflicts)));
     }
 
     $missing = $api->getMissingChanges();
     if ($missing) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n",
           pht(
             'You have missing files in this working copy. Revert or formally '.
             'remove them (with `%s`) before proceeding.',
             'svn rm'),
           $working_copy_desc,
           pht('Missing files in working copy:'),
           implode("\n    ", $missing)));
     }
 
     $externals = $api->getDirtyExternalChanges();
 
     // TODO: This state can exist in Subversion, but it is currently handled
     // elsewhere. It should probably be handled here, eventually.
     if ($api instanceof ArcanistSubversionAPI) {
       $externals = array();
     }
 
     if ($externals) {
       $message = pht(
         '%s submodule(s) have uncommitted or untracked changes:',
         new PhutilNumber(count($externals)));
 
       $prompt = pht(
         'Ignore the changes to these %s submodule(s) and continue?',
         new PhutilNumber(count($externals)));
 
       $list = id(new PhutilConsoleList())
         ->setWrap(false)
         ->addItems($externals);
 
       id(new PhutilConsoleBlock())
         ->addParagraph($message)
         ->addList($list)
         ->draw();
 
       $ok = phutil_console_confirm($prompt, $default_no = false);
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     $uncommitted = $api->getUncommittedChanges();
     $unstaged = $api->getUnstagedChanges();
 
     // We already dealt with externals.
     $unstaged = array_diff($unstaged, $externals);
 
     // We only want files which are purely uncommitted.
     $uncommitted = array_diff($uncommitted, $unstaged);
     $uncommitted = array_diff($uncommitted, $externals);
 
     $untracked = $api->getUntrackedChanges();
     if (!$this->shouldRequireCleanUntrackedFiles()) {
       $untracked = array();
     }
 
     if ($untracked) {
       echo sprintf(
         "%s\n\n%s",
         pht('You have untracked files in this working copy.'),
         $working_copy_desc);
 
       if ($api instanceof ArcanistGitAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.git/info/exclude');
       } else if ($api instanceof ArcanistSubversionAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           'svn:ignore');
       } else if ($api instanceof ArcanistMercurialAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.hgignore');
       }
 
       $untracked_list = "    ".implode("\n    ", $untracked);
       echo sprintf(
         "  %s\n  %s\n%s",
         pht('Untracked changes in working copy:'),
         $hint,
         $untracked_list);
 
       $prompt = pht(
         'Ignore these %s untracked file(s) and continue?',
         phutil_count($untracked));
 
       if (!phutil_console_confirm($prompt)) {
         throw new ArcanistUserAbortException();
       }
     }
 
 
     $should_commit = false;
     if ($unstaged || $uncommitted) {
 
       // NOTE: We're running this because it builds a cache and can take a
       // perceptible amount of time to arrive at an answer, but we don't want
       // to pause in the middle of printing the output below.
       $this->getShouldAmend();
 
       echo sprintf(
         "%s\n\n%s",
         pht('You have uncommitted changes in this working copy.'),
         $working_copy_desc);
 
       $lists = array();
 
       if ($unstaged) {
         $unstaged_list = "    ".implode("\n    ", $unstaged);
         $lists[] = sprintf(
           "  %s\n%s",
           pht('Unstaged changes in working copy:'),
           $unstaged_list);
       }
 
       if ($uncommitted) {
         $uncommitted_list = "    ".implode("\n    ", $uncommitted);
         $lists[] = sprintf(
           "%s\n%s",
           pht('Uncommitted changes in working copy:'),
           $uncommitted_list);
       }
 
       echo implode("\n\n", $lists)."\n";
 
       $all_uncommitted = array_merge($unstaged, $uncommitted);
       if ($this->askForAdd($all_uncommitted)) {
         if ($unstaged) {
           $api->addToCommit($unstaged);
         }
         $should_commit = true;
       } else {
-        $permit_autostash = $this->getConfigFromAnySource(
-          'arc.autostash',
-          false);
+        $permit_autostash = $this->getConfigFromAnySource('arc.autostash');
         if ($permit_autostash && $api->canStashChanges()) {
            echo pht(
             'Stashing uncommitted changes. (You can restore them with `%s`).',
             'git stash pop')."\n";
           $api->stashChanges();
           $this->stashed = true;
         } else {
           throw new ArcanistUsageException(
             pht(
               'You can not continue with uncommitted changes. '.
               'Commit or discard them before proceeding.'));
         }
       }
     }
 
     if ($should_commit) {
       if ($this->getShouldAmend()) {
         $commit = head($api->getLocalCommitInformation());
         $api->amendCommit($commit['message']);
       } else if ($api->supportsLocalCommits()) {
         $template = sprintf(
           "\n\n# %s\n#\n# %s\n#\n",
           pht('Enter a commit message.'),
           pht('Changes:'));
 
         $paths = array_merge($uncommitted, $unstaged);
         $paths = array_unique($paths);
         sort($paths);
 
         foreach ($paths as $path) {
           $template .= "#     ".$path."\n";
         }
 
         $commit_message = $this->newInteractiveEditor($template)
           ->setName(pht('commit-message'))
           ->editInteractively();
 
         if ($commit_message === $template) {
           throw new ArcanistUsageException(
             pht('You must provide a commit message.'));
         }
 
         $commit_message = ArcanistCommentRemover::removeComments(
           $commit_message);
 
         if (!strlen($commit_message)) {
           throw new ArcanistUsageException(
             pht('You must provide a nonempty commit message.'));
         }
 
         $api->doCommit($commit_message);
       }
     }
   }
 
   private function getShouldAmend() {
     if ($this->shouldAmend === null) {
       $this->shouldAmend = $this->calculateShouldAmend();
     }
     return $this->shouldAmend;
   }
 
   private function calculateShouldAmend() {
     $api = $this->getRepositoryAPI();
 
     if ($this->isHistoryImmutable() || !$api->supportsAmend()) {
       return false;
     }
 
     $commits = $api->getLocalCommitInformation();
     if (!$commits) {
       return false;
     }
 
     $commit = reset($commits);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
       $commit['message']);
 
     if ($message->getGitSVNBaseRevision()) {
       return false;
     }
 
     if ($api->getAuthor() != $commit['author']) {
       return false;
     }
 
     if ($message->getRevisionID() && $this->getArgument('create')) {
       return false;
     }
 
     // TODO: Check commits since tracking branch. If empty then return false.
 
     // Don't amend the current commit if it has already been published.
     $repository = $this->loadProjectRepository();
     if ($repository) {
       $repo_id = $repository['id'];
       $commit_hash = $commit['commit'];
       $callsign =  idx($repository, 'callsign');
       if ($callsign) {
         // The server might be too old to support the new style commit names,
         // so prefer the old way
         $commit_name = "r{$callsign}{$commit_hash}";
       } else {
         $commit_name = "R{$repo_id}:{$commit_hash}";
       }
 
       $result = $this->getConduit()->callMethodSynchronous(
         'diffusion.querycommits',
         array('names' => array($commit_name)));
       $known_commit = idx($result['identifierMap'], $commit_name);
       if ($known_commit) {
         return false;
       }
     }
 
     if (!$message->getRevisionID()) {
       return true;
     }
 
     $in_working_copy = $api->loadWorkingCopyDifferentialRevisions(
       $this->getConduit(),
       array(
         'authors' => array($this->getUserPHID()),
         'status' => 'status-open',
       ));
     if ($in_working_copy) {
       return true;
     }
 
     return false;
   }
 
   private function askForAdd(array $files) {
     if ($this->commitMode == self::COMMIT_DISABLE) {
       return false;
     }
     if ($this->commitMode == self::COMMIT_ENABLE) {
       return true;
     }
     $prompt = $this->getAskForAddPrompt($files);
     return phutil_console_confirm($prompt);
   }
 
   private function getAskForAddPrompt(array $files) {
     if ($this->getShouldAmend()) {
       $prompt = pht(
         'Do you want to amend these %s change(s) to the current commit?',
         phutil_count($files));
     } else {
       $prompt = pht(
         'Do you want to create a new commit with these %s change(s)?',
         phutil_count($files));
     }
     return $prompt;
   }
 
   final protected function loadDiffBundleFromConduit(
     ConduitClient $conduit,
     $diff_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'ids' => array($diff_id),
     ));
   }
 
   final protected function loadRevisionBundleFromConduit(
     ConduitClient $conduit,
     $revision_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'revisionIDs' => array($revision_id),
     ));
   }
 
   final private function loadBundleFromConduit(
     ConduitClient $conduit,
     $params) {
 
     $future = $conduit->callMethod('differential.querydiffs', $params);
     $diff = head($future->resolve());
 
     if ($diff == null) {
       throw new Exception(
         phutil_console_wrap(
           pht("The diff or revision you specified is either invalid or you ".
           "don't have permission to view it."))
       );
     }
 
     $changes = array();
     foreach ($diff['changes'] as $changedict) {
       $changes[] = ArcanistDiffChange::newFromDictionary($changedict);
     }
     $bundle = ArcanistBundle::newFromChanges($changes);
     $bundle->setConduit($conduit);
     // since the conduit method has changes, assume that these fields
     // could be unset
     $bundle->setBaseRevision(idx($diff, 'sourceControlBaseRevision'));
     $bundle->setRevisionID(idx($diff, 'revisionID'));
     $bundle->setAuthorName(idx($diff, 'authorName'));
     $bundle->setAuthorEmail(idx($diff, 'authorEmail'));
     return $bundle;
   }
 
   /**
    * Return a list of lines changed by the current diff, or ##null## if the
    * change list is meaningless (for example, because the path is a directory
    * or binary file).
    *
    * @param string      Path within the repository.
    * @param string      Change selection mode (see ArcanistDiffHunk).
    * @return list|null  List of changed line numbers, or null to indicate that
    *                    the path is not a line-oriented text file.
    */
   final protected function getChangedLines($path, $mode) {
     $repository_api = $this->getRepositoryAPI();
     $full_path = $repository_api->getPath($path);
     if (is_dir($full_path)) {
       return null;
     }
 
     if (!file_exists($full_path)) {
       return null;
     }
 
     $change = $this->getChange($path);
 
     if ($change->getFileType() !== ArcanistDiffChangeType::FILE_TEXT) {
       return null;
     }
 
     $lines = $change->getChangedLines($mode);
     return array_keys($lines);
   }
 
   final protected function getChange($path) {
     $repository_api = $this->getRepositoryAPI();
 
     // TODO: Very gross
     $is_git = ($repository_api instanceof ArcanistGitAPI);
     $is_hg = ($repository_api instanceof ArcanistMercurialAPI);
     $is_svn = ($repository_api instanceof ArcanistSubversionAPI);
 
     if ($is_svn) {
       // NOTE: In SVN, we don't currently support a "get all local changes"
       // operation, so special case it.
       if (empty($this->changeCache[$path])) {
         $diff = $repository_api->getRawDiffText($path);
         $parser = $this->newDiffParser();
         $changes = $parser->parseDiff($diff);
         if (count($changes) != 1) {
           throw new Exception(pht('Expected exactly one change.'));
         }
         $this->changeCache[$path] = reset($changes);
       }
     } else if ($is_git || $is_hg) {
       if (empty($this->changeCache)) {
         $changes = $repository_api->getAllLocalChanges();
         foreach ($changes as $change) {
           $this->changeCache[$change->getCurrentPath()] = $change;
         }
       }
     } else {
       throw new Exception(pht('Missing VCS support.'));
     }
 
     if (empty($this->changeCache[$path])) {
       if ($is_git || $is_hg) {
         // This can legitimately occur under git/hg if you make a change,
         // "git/hg commit" it, and then revert the change in the working copy
         // and run "arc lint".
         $change = new ArcanistDiffChange();
         $change->setCurrentPath($path);
         return $change;
       } else {
         throw new Exception(
           pht(
             "Trying to get change for unchanged path '%s'!",
             $path));
       }
     }
 
     return $this->changeCache[$path];
   }
 
   final public function willRunWorkflow() {
     $spec = $this->getCompleteArgumentSpecification();
     foreach ($this->arguments as $arg => $value) {
       if (empty($spec[$arg])) {
         continue;
       }
       $options = $spec[$arg];
       if (!empty($options['supports'])) {
         $system_name = $this->getRepositoryAPI()->getSourceControlSystemName();
         if (!in_array($system_name, $options['supports'])) {
           $extended_info = null;
           if (!empty($options['nosupport'][$system_name])) {
             $extended_info = ' '.$options['nosupport'][$system_name];
           }
           throw new ArcanistUsageException(
             pht(
               "Option '%s' is not supported under %s.",
               "--{$arg}",
               $system_name).
             $extended_info);
         }
       }
     }
   }
 
   final protected function normalizeRevisionID($revision_id) {
     return preg_replace('/^D/i', '', $revision_id);
   }
 
   protected function shouldShellComplete() {
     return true;
   }
 
   protected function getShellCompletions(array $argv) {
     return array();
   }
 
   public function getSupportedRevisionControlSystems() {
     return array('git', 'hg', 'svn');
   }
 
   final protected function getPassthruArgumentsAsMap($command) {
     $map = array();
     foreach ($this->getCompleteArgumentSpecification() as $key => $spec) {
       if (!empty($spec['passthru'][$command])) {
         if (isset($this->arguments[$key])) {
           $map[$key] = $this->arguments[$key];
         }
       }
     }
     return $map;
   }
 
   final protected function getPassthruArgumentsAsArgv($command) {
     $spec = $this->getCompleteArgumentSpecification();
     $map = $this->getPassthruArgumentsAsMap($command);
     $argv = array();
     foreach ($map as $key => $value) {
       $argv[] = '--'.$key;
       if (!empty($spec[$key]['param'])) {
         $argv[] = $value;
       }
     }
     return $argv;
   }
 
   /**
    * Write a message to stderr so that '--json' flags or stdout which is meant
    * to be piped somewhere aren't disrupted.
    *
    * @param string  Message to write to stderr.
    * @return void
    */
   final protected function writeStatusMessage($msg) {
     fwrite(STDERR, $msg);
   }
 
   final public function writeInfo($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:blue>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final public function writeWarn($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:yellow>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final public function writeOkay($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final protected function isHistoryImmutable() {
     $repository_api = $this->getRepositoryAPI();
 
     $config = $this->getConfigFromAnySource('history.immutable');
     if ($config !== null) {
       return $config;
     }
 
     return $repository_api->isHistoryDefaultImmutable();
   }
 
   /**
    * Workflows like 'lint' and 'unit' operate on a list of working copy paths.
    * The user can either specify the paths explicitly ("a.js b.php"), or by
    * specifying a revision ("--rev a3f10f1f") to select all paths modified
    * since that revision, or by omitting both and letting arc choose the
    * default relative revision.
    *
    * This method takes the user's selections and returns the paths that the
    * workflow should act upon.
    *
    * @param   list          List of explicitly provided paths.
    * @param   string|null   Revision name, if provided.
    * @param   mask          Mask of ArcanistRepositoryAPI flags to exclude.
    *                        Defaults to ArcanistRepositoryAPI::FLAG_UNTRACKED.
    * @return  list          List of paths the workflow should act on.
    */
   final protected function selectPathsForWorkflow(
     array $paths,
     $rev,
     $omit_mask = null) {
 
     if ($omit_mask === null) {
       $omit_mask = ArcanistRepositoryAPI::FLAG_UNTRACKED;
     }
 
     if ($paths) {
       $working_copy = $this->getWorkingCopy();
       foreach ($paths as $key => $path) {
         $full_path = Filesystem::resolvePath($path);
         if (!Filesystem::pathExists($full_path)) {
           throw new ArcanistUsageException(
             pht(
               "Path '%s' does not exist!",
               $path));
         }
         $relative_path = Filesystem::readablePath(
           $full_path,
           $working_copy->getProjectRoot());
         $paths[$key] = $relative_path;
       }
     } else {
       $repository_api = $this->getRepositoryAPI();
 
       if ($rev) {
         $this->parseBaseCommitArgument(array($rev));
       }
 
       $paths = $repository_api->getWorkingCopyStatus();
       foreach ($paths as $path => $flags) {
         if ($flags & $omit_mask) {
           unset($paths[$path]);
         }
       }
       $paths = array_keys($paths);
     }
 
     return array_values($paths);
   }
 
   final protected function renderRevisionList(array $revisions) {
     $list = array();
     foreach ($revisions as $revision) {
       $list[] = '     - D'.$revision['id'].': '.$revision['title']."\n";
     }
     return implode('', $list);
   }
 
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   final protected function readScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->readScratchFile($path);
   }
 
 
   /**
    * Try to read a scratch JSON file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return array Empty array for failure.
    * @task scratch
    */
   final protected function readScratchJSONFile($path) {
     $file = $this->readScratchFile($path);
     if (!$file) {
       return array();
     }
     return phutil_json_decode($file);
   }
 
 
   /**
    * Try to write a scratch file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  string Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchFile($path, $data) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->writeScratchFile($path, $data);
   }
 
 
   /**
    * Try to write a scratch JSON file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  array Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchJSONFile($path, array $data) {
     return $this->writeScratchFile($path, json_encode($data));
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   final protected function removeScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->removeScratchFile($path);
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   final protected function getReadableScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getReadableScratchFilePath($path);
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   final protected function getScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getScratchFilePath($path);
   }
 
   final protected function getRepositoryEncoding() {
     return nonempty(
       idx($this->loadProjectRepository(), 'encoding'),
       'UTF-8');
   }
 
   final protected function loadProjectRepository() {
     list($info, $reasons) = $this->loadRepositoryInformation();
     return coalesce($info, array());
   }
 
   final protected function newInteractiveEditor($text) {
     $editor = new PhutilInteractiveEditor($text);
 
     $preferred = $this->getConfigFromAnySource('editor');
     if ($preferred) {
       $editor->setPreferredEditor($preferred);
     }
 
     return $editor;
   }
 
   final protected function newDiffParser() {
     $parser = new ArcanistDiffParser();
     if ($this->repositoryAPI) {
       $parser->setRepositoryAPI($this->getRepositoryAPI());
     }
     $parser->setWriteDiffOnFailure(true);
     return $parser;
   }
 
   final protected function resolveCall(ConduitFuture $method, $timeout = null) {
     try {
       return $method->resolve($timeout);
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-CONDUIT-CALL') {
         echo phutil_console_wrap(
           pht(
             'This feature requires a newer version of Phabricator. Please '.
             'update it using these instructions: %s',
             'https://secure.phabricator.com/book/phabricator/article/'.
               'upgrading/')."\n\n");
       }
       throw $ex;
     }
   }
 
   final protected function dispatchEvent($type, array $data) {
     $data += array(
       'workflow' => $this,
     );
 
     $event = new PhutilEvent($type, $data);
     PhutilEventEngine::dispatchEvent($event);
 
     return $event;
   }
 
   final public function parseBaseCommitArgument(array $argv) {
     if (!count($argv)) {
       return;
     }
 
     $api = $this->getRepositoryAPI();
     if (!$api->supportsCommitRanges()) {
       throw new ArcanistUsageException(
         pht('This version control system does not support commit ranges.'));
     }
 
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         pht(
           'Specify exactly one base commit. The end of the commit range is '.
           'always the working copy state.'));
     }
 
     $api->setBaseCommit(head($argv));
 
     return $this;
   }
 
   final protected function getRepositoryVersion() {
     if (!$this->repositoryVersion) {
       $api = $this->getRepositoryAPI();
       $commit = $api->getSourceControlBaseRevision();
       $versions = array('' => $commit);
       foreach ($api->getChangedFiles($commit) as $path => $mask) {
         $versions[$path] = (Filesystem::pathExists($path)
           ? md5_file($path)
           : '');
       }
       $this->repositoryVersion = md5(json_encode($versions));
     }
     return $this->repositoryVersion;
   }
 
 
 /* -(  Phabricator Repositories  )------------------------------------------- */
 
 
   /**
    * Get the PHID of the Phabricator repository this working copy corresponds
    * to. Returns `null` if no repository can be identified.
    *
    * @return phid|null  Repository PHID, or null if no repository can be
    *                    identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryPHID() {
     return idx($this->getRepositoryInformation(), 'phid');
   }
 
   /**
    * Get the name of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository name, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryName() {
     return idx($this->getRepositoryInformation(), 'name');
   }
 
 
   /**
    * Get the URI of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository URI, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryURI() {
     return idx($this->getRepositoryInformation(), 'uri');
   }
 
 
   final protected function getRepositoryStagingConfiguration() {
     return idx($this->getRepositoryInformation(), 'staging');
   }
 
 
   /**
    * Get human-readable reasoning explaining how `arc` evaluated which
    * Phabricator repository corresponds to this working copy. Used by
    * `arc which` to explain the process to users.
    *
    * @return list<string> Human-readable explanation of the repository
    *                      association process.
    *
    * @task phabrep
    */
   final protected function getRepositoryReasons() {
     $this->getRepositoryInformation();
     return $this->repositoryReasons;
   }
 
 
   /**
    * @task phabrep
    */
   private function getRepositoryInformation() {
     if ($this->repositoryInfo === null) {
       list($info, $reasons) = $this->loadRepositoryInformation();
       $this->repositoryInfo = nonempty($info, array());
       $this->repositoryReasons = $reasons;
     }
 
     return $this->repositoryInfo;
   }
 
 
   /**
    * @task phabrep
    */
   private function loadRepositoryInformation() {
     list($query, $reasons) = $this->getRepositoryQuery();
     if (!$query) {
       return array(null, $reasons);
     }
 
     try {
       $results = $this->getConduit()->callMethodSynchronous(
         'repository.query',
         $query);
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-CONDUIT-CALL') {
         $reasons[] = pht(
           'This version of Arcanist is more recent than the version of '.
           'Phabricator you are connecting to: the Phabricator install is '.
           'out of date and does not have support for identifying '.
           'repositories by callsign or URI. Update Phabricator to enable '.
           'these features.');
         return array(null, $reasons);
       }
       throw $ex;
     }
 
     $result = null;
     if (!$results) {
       $reasons[] = pht(
         'No repositories matched the query. Check that your configuration '.
         'is correct, or use "%s" to select a repository explicitly.',
         'repository.callsign');
     } else if (count($results) > 1) {
       $reasons[] = pht(
         'Multiple repostories (%s) matched the query. You can use the '.
         '"%s" configuration to select the one you want.',
         implode(', ', ipull($results, 'callsign')),
         'repository.callsign');
     } else {
       $result = head($results);
       $reasons[] = pht('Found a unique matching repository.');
     }
 
     return array($result, $reasons);
   }
 
 
   /**
    * @task phabrep
    */
   private function getRepositoryQuery() {
     $reasons = array();
 
     $callsign = $this->getConfigFromAnySource('repository.callsign');
     if ($callsign) {
       $query = array(
         'callsigns' => array($callsign),
       );
       $reasons[] = pht(
         'Configuration value "%s" is set to "%s".',
         'repository.callsign',
         $callsign);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'Configuration value "%s" is empty.',
         'repository.callsign');
     }
 
     $uuid = $this->getRepositoryAPI()->getRepositoryUUID();
     if ($uuid !== null) {
       $query = array(
         'uuids' => array($uuid),
       );
       $reasons[] = pht(
         'The UUID for this working copy is "%s".',
         $uuid);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'This repository has no VCS UUID (this is normal for git/hg).');
     }
 
     $remote_uri = $this->getRepositoryAPI()->getRemoteURI();
     if ($remote_uri !== null) {
       $query = array(
         'remoteURIs' => array($remote_uri),
       );
       $reasons[] = pht(
         'The remote URI for this working copy is "%s".',
         $remote_uri);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'Unable to determine the remote URI for this repository.');
     }
 
     return array(null, $reasons);
   }
 
 
   /**
    * Build a new lint engine for the current working copy.
    *
    * Optionally, you can pass an explicit engine class name to build an engine
    * of a particular class. Normally this is used to implement an `--engine`
    * flag from the CLI.
    *
    * @param string Optional explicit engine class name.
    * @return ArcanistLintEngine Constructed engine.
    */
   protected function newLintEngine($engine_class = null) {
     $working_copy = $this->getWorkingCopy();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('lint.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arclint'))) {
         $engine_class = 'ArcanistConfigurationDrivenLintEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No lint engine is configured for this project. Create an '%s' ".
           "file, or configure an advanced engine with '%s' in '%s'.",
           '.arclint',
           'lint.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistLintEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured lint engine "%s" is not a subclass of "%s", but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
   /**
    * Build a new unit test engine for the current working copy.
    *
    * Optionally, you can pass an explicit engine class name to build an engine
    * of a particular class. Normally this is used to implement an `--engine`
    * flag from the CLI.
    *
    * @param string Optional explicit engine class name.
    * @return ArcanistUnitTestEngine Constructed engine.
    */
   protected function newUnitTestEngine($engine_class = null) {
     $working_copy = $this->getWorkingCopy();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('unit.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arcunit'))) {
         $engine_class = 'ArcanistConfigurationDrivenUnitTestEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No unit test engine is configured for this project. Create an ".
           "'%s' file, or configure an advanced engine with '%s' in '%s'.",
           '.arcunit',
           'unit.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistUnitTestEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured unit test engine "%s" is not a subclass of "%s", '.
           'but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
 
   protected function openURIsInBrowser(array $uris) {
     $browser = $this->getBrowserCommand();
     foreach ($uris as $uri) {
       $err = phutil_passthru('%s %s', $browser, $uri);
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             "Failed to open '%s' in browser ('%s'). ".
             "Check your 'browser' config option.",
             $uri,
             $browser));
       }
     }
   }
 
   private function getBrowserCommand() {
     $config = $this->getConfigFromAnySource('browser');
     if ($config) {
       return $config;
     }
 
     if (phutil_is_windows()) {
       return 'start';
     }
 
     $candidates = array('sensible-browser', 'xdg-open', 'open');
 
     // NOTE: The "open" command works well on OS X, but on many Linuxes "open"
     // exists and is not a browser. For now, we're just looking for other
     // commands first, but we might want to be smarter about selecting "open"
     // only on OS X.
 
     foreach ($candidates as $cmd) {
       if (Filesystem::binaryExists($cmd)) {
         return $cmd;
       }
     }
 
     throw new ArcanistUsageException(
       pht(
         "Unable to find a browser command to run. Set '%s' in your ".
         "Arcanist config to specify a command to use.",
         'browser'));
   }
 
 
   /**
    * Ask Phabricator to update the current repository as soon as possible.
    *
    * Calling this method after pushing commits allows Phabricator to discover
    * the commits more quickly, so the system overall is more responsive.
    *
    * @return void
    */
   protected function askForRepositoryUpdate() {
     // If we know which repository we're in, try to tell Phabricator that we
     // pushed commits to it so it can update. This hint can help pull updates
     // more quickly, especially in rarely-used repositories.
     if ($this->getRepositoryPHID()) {
       try {
         $this->getConduit()->callMethodSynchronous(
           'diffusion.looksoon',
           array(
             'repositories' => array($this->getRepositoryPHID()),
           ));
       } catch (ConduitClientException $ex) {
         // If we hit an exception, just ignore it. Likely, we are running
         // against a Phabricator which is too old to support this method.
         // Since this hint is purely advisory, it doesn't matter if it has
         // no effect.
       }
     }
   }
 
   protected function getModernLintDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
     return $map;
   }
 
   protected function getModernUnitDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
 
     $details = idx($map, 'userData');
     if (strlen($details)) {
       $map['details'] = (string)$details;
     }
     unset($map['userData']);
 
     return $map;
   }
 
   private function getModernCommonDictionary(array $map) {
     foreach ($map as $key => $value) {
       if ($value === null) {
         unset($map[$key]);
       }
     }
     return $map;
   }
 
 
 }