diff --git a/scripts/__init_script__.php b/scripts/__init_script__.php
index 742f5dab..9f7486b6 100644
--- a/scripts/__init_script__.php
+++ b/scripts/__init_script__.php
@@ -1,108 +1,107 @@
 <?php
 
 /**
  * Adjust 'include_path' to add locations where we'll search for libphutil.
  * We look in these places:
  *
  *  - Next to 'arcanist/'.
  *  - Anywhere in the normal PHP 'include_path'.
  *  - Inside 'arcanist/externals/includes/'.
  *
  * When looking in these places, we expect to find a 'libphutil/' directory.
  */
 function arcanist_adjust_php_include_path() {
-
   // The 'arcanist/' directory.
   $arcanist_dir = dirname(dirname(__FILE__));
 
   // The parent directory of 'arcanist/'.
   $parent_dir = dirname($arcanist_dir);
 
   // The 'arcanist/externals/includes/' directory.
   $include_dir = implode(
     DIRECTORY_SEPARATOR,
     array(
       $arcanist_dir,
       'externals',
       'includes',
     ));
 
   $php_include_path = ini_get('include_path');
   $php_include_path = implode(
     PATH_SEPARATOR,
     array(
       $parent_dir,
       $php_include_path,
       $include_dir,
     ));
 
   ini_set('include_path', $php_include_path);
 }
 arcanist_adjust_php_include_path();
 
 if (getenv('ARC_PHUTIL_PATH')) {
   @include_once getenv('ARC_PHUTIL_PATH').'/scripts/__init_script__.php';
 } else {
   @include_once 'libphutil/scripts/__init_script__.php';
 }
 if (!@constant('__LIBPHUTIL__')) {
   echo "ERROR: Unable to load libphutil. Put libphutil/ next to arcanist/, or ".
        "update your PHP 'include_path' to include the parent directory of ".
        "libphutil/, or symlink libphutil/ into arcanist/externals/includes/.\n";
   exit(1);
 }
 
 PhutilTranslator::getInstance()
   ->addTranslations(array(
     'Locally modified path(s) are not included in this revision:' => array(
       'A locally modified path is not included in this revision:',
       'Locally modified paths are not included in this revision:',
     ),
     'They will NOT be committed. Commit this revision anyway?' => array(
       'It will NOT be committed. Commit this revision anyway?',
       'They will NOT be committed. Commit this revision anyway?',
     ),
     'Revision includes changes to path(s) that do not exist:' => array(
       'Revision includes changes to a path that does not exist:',
       'Revision includes changes to paths that do not exist:',
     ),
 
     'This diff includes file(s) which are not valid UTF-8 (they contain '.
       'invalid byte sequences). You can either stop this workflow and fix '.
       'these files, or continue. If you continue, these files will be '.
       'marked as binary.' => array(
       'This diff includes a file which is not valid UTF-8 (it has invalid '.
         'byte sequences). You can either stop this workflow and fix it, or '.
         'continue. If you continue, this file will be marked as binary.',
       'This diff includes files which are not valid UTF-8 (they contain '.
         'invalid byte sequences). You can either stop this workflow and fix '.
         'these files, or continue. If you continue, these files will be '.
         'marked as binary.',
     ),
     'AFFECTED FILE(S)' => array('AFFECTED FILE', 'AFFECTED FILES'),
     'Do you want to mark these files as binary and continue?' => array(
       'Do you want to mark this file as binary and continue?',
       'Do you want to mark these files as binary and continue?',
     ),
 
     'Do you want to amend these files to the commit?' => array(
       'Do you want to amend this file to the commit?',
       'Do you want to amend these files to the commit?',
     ),
 
     'Do you want to add these files to the commit?' => array(
       'Do you want to add this file to the commit?',
       'Do you want to add these files to the commit?',
     ),
 
     'line(s)' => array('line', 'lines'),
 
     '%d test(s)' => array('%d test', '%d tests'),
 
     '%d assertion(s) passed.' => array(
       '%d assertion passed.',
       '%d assertions passed.',
     ),
   ));
 
 phutil_load_library(dirname(dirname(__FILE__)).'/src/');
diff --git a/src/configuration/ArcanistConfiguration.php b/src/configuration/ArcanistConfiguration.php
index b5a89f1a..f8dbebe4 100644
--- a/src/configuration/ArcanistConfiguration.php
+++ b/src/configuration/ArcanistConfiguration.php
@@ -1,268 +1,270 @@
 <?php
 
 /**
  * Runtime workflow configuration. In Arcanist, commands you type like
  * "arc diff" or "arc lint" are called "workflows". This class allows you to add
  * new workflows (and extend existing workflows) by subclassing it and then
  * pointing to your subclass in your project configuration.
  *
  * When specified as the **arcanist_configuration** class in your project's
  * ##.arcconfig##, your subclass will be instantiated (instead of this class)
  * and be able to handle all the method calls. In particular, you can:
  *
  *    - create, replace, or disable workflows by overriding buildWorkflow()
  *      and buildAllWorkflows();
  *    - add additional steps before or after workflows run by overriding
  *      willRunWorkflow() or didRunWorkflow() or didAbortWorkflow(); and
  *    - add new flags to existing workflows by overriding
  *      getCustomArgumentsForCommand().
  *
- * @group config
  * @concrete-extensible
  */
 class ArcanistConfiguration {
 
   public function buildWorkflow($command) {
     if ($command == '--help') {
       // Special-case "arc --help" to behave like "arc help" instead of telling
       // you to type "arc help" without being helpful.
       $command = 'help';
     } else if ($command == '--version') {
       // Special-case "arc --version" to behave like "arc version".
       $command = 'version';
     }
 
     return idx($this->buildAllWorkflows(), $command);
   }
 
   public function buildAllWorkflows() {
     $workflows_by_name = array();
 
     $workflows_by_class_name = id(new PhutilSymbolLoader())
       ->setAncestorClass('ArcanistBaseWorkflow')
       ->loadObjects();
     foreach ($workflows_by_class_name as $class => $workflow) {
       $name = $workflow->getWorkflowName();
 
       if (isset($workflows_by_name[$name])) {
         $other = get_class($workflows_by_name[$name]);
         throw new Exception(
           "Workflows {$class} and {$other} both implement workflows named ".
           "{$name}.");
       }
 
       $workflows_by_name[$name] = $workflow;
     }
 
     return $workflows_by_name;
   }
 
   final public function isValidWorkflow($workflow) {
     return (bool)$this->buildWorkflow($workflow);
   }
 
   public function willRunWorkflow($command, ArcanistBaseWorkflow $workflow) {
     // This is a hook.
   }
 
-  public function didRunWorkflow($command, ArcanistBaseWorkflow $workflow,
-                                 $err) {
+  public function didRunWorkflow(
+    $command,
+    ArcanistBaseWorkflow $workflow,
+    $err) {
+
     // This is a hook.
   }
 
   public function didAbortWorkflow($command, $workflow, Exception $ex) {
     // This is a hook.
   }
 
   public function getCustomArgumentsForCommand($command) {
     return array();
   }
 
   final public function selectWorkflow(
     &$command,
     array &$args,
     ArcanistConfigurationManager $configuration_manager,
     PhutilConsole $console) {
 
     // First, try to build a workflow with the exact name provided. We always
     // pick an exact match, and do not allow aliases to override it.
     $workflow = $this->buildWorkflow($command);
     if ($workflow) {
       return $workflow;
     }
 
     // If the user has an alias, like 'arc alias dhelp diff help', look it up
     // and substitute it. We do this only after trying to resolve the workflow
     // normally to prevent you from doing silly things like aliasing 'alias'
     // to something else.
     $aliases = ArcanistAliasWorkflow::getAliases($configuration_manager);
     list($new_command, $args) = ArcanistAliasWorkflow::resolveAliases(
       $command,
       $this,
       $args,
       $configuration_manager);
 
     $full_alias = idx($aliases, $command, array());
     $full_alias = implode(' ', $full_alias);
 
     // Run shell command aliases.
     if (ArcanistAliasWorkflow::isShellCommandAlias($new_command)) {
       $shell_cmd = substr($full_alias, 1);
 
       $console->writeLog(
         "[alias: 'arc %s' -> $ %s]",
         $command,
         $shell_cmd);
 
       if ($args) {
         $err = phutil_passthru('%C %Ls', $shell_cmd, $args);
       } else {
         $err = phutil_passthru('%C', $shell_cmd);
       }
 
       exit($err);
     }
 
     // Run arc command aliases.
     if ($new_command) {
       $workflow = $this->buildWorkflow($new_command);
       if ($workflow) {
         $console->writeLog(
           "[alias: 'arc %s' -> 'arc %s']\n",
           $command,
           $full_alias);
         $command = $new_command;
         return $workflow;
       }
     }
 
     $all = array_keys($this->buildAllWorkflows());
 
     // We haven't found a real command or an alias, so try to locate a command
     // by unique prefix.
     $prefixes = $this->expandCommandPrefix($command, $all);
 
     if (count($prefixes) == 1) {
       $command = head($prefixes);
       return $this->buildWorkflow($command);
     } else if (count($prefixes) > 1) {
       $this->raiseUnknownCommand($command, $prefixes);
     }
 
 
     // We haven't found a real command, alias, or unique prefix. Try similar
     // spellings.
     $corrected = self::correctCommandSpelling($command, $all, 2);
     if (count($corrected) == 1) {
       $console->writeErr(
         pht(
           "(Assuming '%s' is the British spelling of '%s'.)",
           $command,
           head($corrected))."\n");
       $command = head($corrected);
       return $this->buildWorkflow($command);
     } else if (count($corrected) > 1) {
       $this->raiseUnknownCommand($command, $corrected);
     }
 
     $this->raiseUnknownCommand($command);
   }
 
   private function raiseUnknownCommand($command, array $maybe = array()) {
     $message = pht("Unknown command '%s'. Try 'arc help'.", $command);
     if ($maybe) {
       $message .= "\n\n".pht('Did you mean:')."\n";
       sort($maybe);
       foreach ($maybe as $other) {
         $message .= "    ".$other."\n";
       }
     }
     throw new ArcanistUsageException($message);
   }
 
   private function expandCommandPrefix($command, array $options) {
     $is_prefix = array();
     foreach ($options as $option) {
       if (strncmp($option, $command, strlen($command)) == 0) {
         $is_prefix[$option] = true;
       }
     }
 
     return array_keys($is_prefix);
   }
 
   public static function correctCommandSpelling(
     $command,
     array $options,
     $max_distance) {
 
     // Adjust to the scaled edit costs we use below, so "2" roughly means
     // "2 edits".
     $max_distance = $max_distance * 3;
 
     // These costs are somewhat made up, but the theory is that it is far more
     // likely you will mis-strike a key ("lans" for "land") or press two keys
     // out of order ("alnd" for "land") than omit keys or press extra keys.
     $matrix = id(new PhutilEditDistanceMatrix())
       ->setInsertCost(4)
       ->setDeleteCost(4)
       ->setReplaceCost(3)
       ->setTransposeCost(2);
 
     return self::correctSpelling($command, $options, $matrix, $max_distance);
   }
 
   public static function correctArgumentSpelling($command, array $options) {
     $max_distance = 1;
 
     // We are stricter with arguments - we allow only one inserted or deleted
     // character. It is mainly to handle cases like --no-lint versus --nolint
     // or --reviewer versus --reviewers.
     $matrix = id(new PhutilEditDistanceMatrix())
       ->setInsertCost(1)
       ->setDeleteCost(1)
       ->setReplaceCost(10);
 
     return self::correctSpelling($command, $options, $matrix, $max_distance);
   }
 
   public static function correctSpelling(
     $input,
     array $options,
     PhutilEditDistanceMatrix $matrix,
     $max_distance) {
 
     $distances = array();
     $inputv = str_split($input);
     foreach ($options as $option) {
       $optionv = str_split($option);
       $matrix->setSequences($optionv, $inputv);
       $distances[$option] = $matrix->getEditDistance();
     }
 
     asort($distances);
     $best = min($max_distance, reset($distances));
     foreach ($distances as $option => $distance) {
       if ($distance > $best) {
         unset($distances[$option]);
       }
     }
 
     // Before filtering, check if we have multiple equidistant matches and
     // return them if we do. This prevents us from, e.g., matching "alnd" with
     // both "land" and "amend", then dropping "land" for being too short, and
     // incorrectly completing to "amend".
     if (count($distances) > 1) {
       return array_keys($distances);
     }
 
     foreach ($distances as $option => $distance) {
       if (strlen($option) < $distance) {
         unset($distances[$option]);
       }
     }
 
     return array_keys($distances);
   }
 
 }
diff --git a/src/configuration/ArcanistConfigurationManager.php b/src/configuration/ArcanistConfigurationManager.php
index 38caf2e6..9d5ab534 100644
--- a/src/configuration/ArcanistConfigurationManager.php
+++ b/src/configuration/ArcanistConfigurationManager.php
@@ -1,340 +1,338 @@
 <?php
 
 /**
  * This class holds everything related to configuration and configuration files.
- *
- * @group config
  */
 final class ArcanistConfigurationManager {
 
   private $runtimeConfig = array();
   private $workingCopy = null;
   private $customArcrcFilename = null;
   private $userConfigCache = null;
 
   public function setWorkingCopyIdentity(
     ArcanistWorkingCopyIdentity $working_copy) {
     $this->workingCopy = $working_copy;
   }
 
 /* -(  Get config  )--------------------------------------------------------- */
 
   const CONFIG_SOURCE_RUNTIME = 'runtime';
   const CONFIG_SOURCE_LOCAL   = 'local';
   const CONFIG_SOURCE_PROJECT = 'project';
   const CONFIG_SOURCE_USER    = 'user';
   const CONFIG_SOURCE_SYSTEM  = 'system';
   const CONFIG_SOURCE_DEFAULT = 'default';
 
   public function getProjectConfig($key) {
     if ($this->workingCopy) {
       return $this->workingCopy->getProjectConfig($key);
     }
     return null;
   }
 
   public function getLocalConfig($key) {
     if ($this->workingCopy) {
       return $this->workingCopy->getLocalConfig($key);
     }
     return null;
   }
 
   public function getWorkingCopyIdentity() {
     return $this->workingCopy;
   }
 
   /**
    * Read a configuration directive from any available configuration source.
    * This includes the directive in local, user and system configuration in
    * addition to project configuration, and configuration provided as command
    * arguments ("runtime").
    * The precedence is runtime > local > project > user > system
    *
    * @param key   Key to read.
    * @param wild  Default value if key is not found.
    * @return wild Value, or default value if not found.
    *
    * @task config
    */
   public function getConfigFromAnySource($key, $default = null) {
     $all = $this->getConfigFromAllSources($key);
     return empty($all) ? $default : head($all);
   }
 
   /**
    * For the advanced case where you want customized configuration handling.
    *
    * Reads the configuration from all available sources, returning a map (array)
    * of results, with the source as key. Missing values will not be in the map,
    * so an empty array will be returned if no results are found.
    *
    * The map is ordered by the canonical sources precedence, which is:
    * runtime > local > project > user > system
    *
    * @param key   Key to read
    * @return array Mapping of source => value read. Sources with no value are
    *               not in the array.
    *
    * @task config
    */
   public function getConfigFromAllSources($key) {
     $results = array();
     $settings = new ArcanistSettings();
 
     $pval = idx($this->runtimeConfig, $key);
     if ($pval !== null) {
       $results[self::CONFIG_SOURCE_RUNTIME] =
         $settings->willReadValue($key, $pval);
     }
 
     $pval = $this->getLocalConfig($key);
     if ($pval !== null) {
       $results[self::CONFIG_SOURCE_LOCAL] =
         $settings->willReadValue($key, $pval);
     }
 
     $pval = $this->getProjectConfig($key);
     if ($pval !== null) {
       $results[self::CONFIG_SOURCE_PROJECT] =
         $settings->willReadValue($key, $pval);
     }
 
     $user_config = $this->readUserArcConfig();
     $pval = idx($user_config, $key);
     if ($pval !== null) {
       $results[self::CONFIG_SOURCE_USER] =
         $settings->willReadValue($key, $pval);
     }
 
     $system_config = $this->readSystemArcConfig();
     $pval = idx($system_config, $key);
     if ($pval !== null) {
       $results[self::CONFIG_SOURCE_SYSTEM] =
         $settings->willReadValue($key, $pval);
     }
 
     $default_config = $this->readDefaultConfig();
     if (array_key_exists($key, $default_config)) {
       $results[self::CONFIG_SOURCE_DEFAULT] = $default_config[$key];
     }
 
     return $results;
   }
 
   /**
    * Sets a runtime config value that takes precedence over any static
    * config values.
    *
    * @param key   Key to set.
    * @param value The value of the key.
    *
    * @task config
    */
   public function setRuntimeConfig($key, $value) {
     $this->runtimeConfig[$key] = $value;
 
     return $this;
   }
 
 /* -(  Read/write config )--------------------------------------------------- */
 
   public function readLocalArcConfig() {
     if ($this->workingCopy) {
       return $this->workingCopy->readLocalArcConfig();
     }
 
     return array();
   }
 
   public function writeLocalArcConfig(array $config) {
     if ($this->workingCopy) {
       return $this->workingCopy->writeLocalArcConfig($config);
     }
 
     throw new Exception(pht('No working copy to write config to!'));
   }
 
   /**
    * This is probably not the method you're looking for; try
    * @{method:readUserArcConfig}.
    */
   public function readUserConfigurationFile() {
     if ($this->userConfigCache === null) {
       $user_config = array();
       $user_config_path = $this->getUserConfigurationFileLocation();
 
       $console = PhutilConsole::getConsole();
       if (Filesystem::pathExists($user_config_path)) {
         $console->writeLog(
           "%s\n",
           pht(
             'Config: Reading user configuration file "%s"...',
             $user_config_path));
 
         if (!phutil_is_windows()) {
           $mode = fileperms($user_config_path);
           if (!$mode) {
             throw new Exception(
               pht(
                 'Unable to read file permissions for "%s"!',
                 $user_config_path));
           }
           if ($mode & 0177) {
             // Mode should allow only owner access.
             $prompt = "File permissions on your ~/.arcrc are too open. ".
                       "Fix them by chmod'ing to 600?";
             if (!phutil_console_confirm($prompt, $default_no = false)) {
               throw new ArcanistUsageException(
                 'Set ~/.arcrc to file mode 600.');
             }
             execx('chmod 600 %s', $user_config_path);
 
             // Drop the stat cache so we don't read the old permissions if
             // we end up here again. If we don't do this, we may prompt the user
             // to fix permissions multiple times.
             clearstatcache();
           }
         }
 
         $user_config_data = Filesystem::readFile($user_config_path);
         try {
           $user_config = phutil_json_decode($user_config_data);
         } catch (PhutilJSONParserException $ex) {
           throw new PhutilProxyException(
             "Your '~/.arcrc' file is not a valid JSON file.".
             $ex);
         }
       } else {
         $console->writeLog(
           "%s\n",
           pht(
             'Config: Did not find user configuration at "%s".',
             $user_config_path));
       }
 
       $this->userConfigCache = $user_config;
     }
 
     return $this->userConfigCache;
   }
 
   /**
    * This is probably not the method you're looking for; try
    * @{method:writeUserArcConfig}.
    */
   public function writeUserConfigurationFile($config) {
     $json_encoder = new PhutilJSON();
     $json = $json_encoder->encodeFormatted($config);
 
     $path = $this->getUserConfigurationFileLocation();
     Filesystem::writeFile($path, $json);
 
     if (!phutil_is_windows()) {
       execx('chmod 600 %s', $path);
     }
   }
 
   public function setUserConfigurationFileLocation($custom_arcrc) {
     if (!Filesystem::pathExists($custom_arcrc)) {
       throw new Exception(
         'Custom arcrc file was specified, but it was not found!');
     }
 
     $this->customArcrcFilename = $custom_arcrc;
     $this->userConfigCache = null;
   }
 
   public function getUserConfigurationFileLocation() {
     if (strlen($this->customArcrcFilename)) {
       return $this->customArcrcFilename;
     }
 
     if (phutil_is_windows()) {
       return getenv('APPDATA').'/.arcrc';
     } else {
       return getenv('HOME').'/.arcrc';
     }
   }
 
   public function readUserArcConfig() {
     return idx($this->readUserConfigurationFile(), 'config', array());
   }
 
   public function writeUserArcConfig(array $options) {
     $config = $this->readUserConfigurationFile();
     $config['config'] = $options;
     $this->writeUserConfigurationFile($config);
   }
 
   public function getSystemArcConfigLocation() {
     if (phutil_is_windows()) {
       return Filesystem::resolvePath(
         'Phabricator/Arcanist/config',
         getenv('ProgramData'));
     } else {
       return '/etc/arcconfig';
     }
   }
 
   public function readSystemArcConfig() {
     static $system_config;
     if ($system_config === null) {
       $system_config = array();
       $system_config_path = $this->getSystemArcConfigLocation();
 
       $console = PhutilConsole::getConsole();
 
       if (Filesystem::pathExists($system_config_path)) {
         $console->writeLog(
           "%s\n",
           pht(
             'Config: Reading system configuration file "%s"...',
             $system_config_path));
         $file = Filesystem::readFile($system_config_path);
         try {
           $system_config = phutil_json_decode($file);
         } catch (PhutilJSONParserException $ex) {
           throw new PhutilProxyException(
             pht(
               "Your '%s' file is not a valid JSON file.",
               $system_config_path),
             $ex);
         }
       } else {
         $console->writeLog(
           "%s\n",
           pht(
             'Config: Did not find system configuration at "%s".',
             $system_config_path));
       }
     }
 
     return $system_config;
   }
 
   public function applyRuntimeArcConfig($args) {
     $arcanist_settings = new ArcanistSettings();
     $options = $args->getArg('config');
 
     foreach ($options as $opt) {
       $opt_config = preg_split('/=/', $opt, 2);
       if (count($opt_config) !== 2) {
         throw new ArcanistUsageException("Argument was '{$opt}', but must be ".
         "'name=value'. For example, history.immutable=true");
       }
 
       list($key, $value) = $opt_config;
       $value = $arcanist_settings->willWriteValue($key, $value);
       $this->setRuntimeConfig($key, $value);
     }
 
     return $this->runtimeConfig;
   }
 
   public function readDefaultConfig() {
     $settings = new ArcanistSettings();
     return $settings->getDefaultSettings();
   }
 
 }
diff --git a/src/configuration/ArcanistSettings.php b/src/configuration/ArcanistSettings.php
index a89ef574..180b3673 100644
--- a/src/configuration/ArcanistSettings.php
+++ b/src/configuration/ArcanistSettings.php
@@ -1,333 +1,329 @@
 <?php
 
-/**
- * @group config
- */
 final class ArcanistSettings {
 
   private function getOptions() {
     return array(
       'default' => array(
         'type' => 'string',
         'help' =>
           'The URI of a Phabricator install to connect to by default, if '.
           'arc is run in a project without a Phabricator URI or run outside '.
           'of a project.',
         'example' => '"http://phabricator.example.com/"',
       ),
       'base' => array(
         'type' => 'string',
         'help' =>
           'Base commit ruleset to invoke when determining the start of a '.
           'commit range. See "Arcanist User Guide: Commit Ranges" for '.
           'details.',
         'example' => '"arc:amended, arc:prompt"',
       ),
       'load' => array(
         'type' => 'list',
         'legacy' => 'phutil_libraries',
         'help' =>
           'A list of paths to phutil libraries that should be loaded at '.
           'startup. This can be used to make classes available, like lint or '.
           'unit test engines.',
         'example' => '["/var/arc/customlib/src"]',
         'default' => array(),
       ),
       'repository.callsign' => array(
         'type' => 'string',
         'example' => '"X"',
         'help' => pht(
           'Associate the working copy with a specific Phabricator repository. '.
           'Normally, arc can figure this association out on its own, but if '.
           'your setup is unusual you can use this option to tell it what the '.
           'desired value is.'),
       ),
       'phabricator.uri' => array(
         'type' => 'string',
         'legacy' => 'conduit_uri',
         'example' => '"https://phabricator.mycompany.com/"',
         'help' => pht(
           'Associates this working copy with a specific installation of '.
           'Phabricator.'),
       ),
       'project.name' => array(
         'type' => 'string',
         'legacy' => 'project_id',
         'example' => '"arcanist"',
         'help' => pht(
           'Associates this working copy with a named Arcanist Project. '.
           'This is primarily useful if you use SVN and have several different '.
           'projects in the same repository.'),
       ),
       'lint.engine' => array(
         'type' => 'string',
         'legacy' => 'lint_engine',
         'help' =>
           'The name of a default lint engine to use, if no lint engine is '.
           'specified by the current project.',
         'example' => '"ExampleLintEngine"',
       ),
       'unit.engine' => array(
         'type' => 'string',
         'legacy' => 'unit_engine',
         'help' =>
           'The name of a default unit test engine to use, if no unit test '.
           'engine is specified by the current project.',
         'example' => '"ExampleUnitTestEngine"',
       ),
       'arc.feature.start.default' => array(
         'type' => 'string',
         'help' =>
           'The name of the default branch to create the new feature branch '.
           'off of.',
         'example' => '"develop"',
       ),
       'arc.land.onto.default' => array(
         'type' => 'string',
         'help' =>
           'The name of the default branch to land changes onto when '.
           '`arc land` is run.',
         'example' => '"develop"',
       ),
       'arc.land.update.default' => array(
         'type' => 'string',
         'help' =>
           'The default strategy to use when arc land updates the feature '.
           'branch. Supports \'rebase\' and \'merge\' strategies.',
         'example' => '"rebase"',
       ),
       'arc.lint.cache' => array(
         'type' => 'bool',
         'help' =>
           "Enable the lint cache by default. When enabled, 'arc lint' ".
           "attempts to use cached results if possible. Currently, the cache ".
           "is not always invalidated correctly and may cause 'arc lint' to ".
           "report incorrect results, particularly while developing linters. ".
           "This is probably worth enabling only if your linters are very slow.",
         'example' => 'false',
         'default' => false,
       ),
       'history.immutable' => array(
         'type' => 'bool',
         'legacy' => 'immutable_history',
         'help' =>
           'If true, arc will never change repository history (e.g., through '.
           'amending or rebasing). Defaults to true in Mercurial and false in '.
           'Git. This setting has no effect in Subversion.',
         'example' => 'false',
         'default' => false,
       ),
       'editor' => array(
         'type' => 'string',
         'help' =>
           "Command to use to invoke an interactive editor, like 'nano' or ".
           "'vim'. This setting overrides the EDITOR environmental variable.",
         'example' => '"nano"',
       ),
       'https.cabundle' => array(
         'type' => 'string',
         'help' =>
           "Path to a custom CA bundle file to be used for arcanist's cURL ".
           "calls. This is used primarily when your conduit endpoint is ".
           "behind https signed by your organization's internal CA.",
         'example' => 'support/yourca.pem'
       ),
       'https.blindly-trust-domains' => array(
         'type' => 'list',
         'help' => 'List of domains to blindly trust SSL certificates for. '.
                   'Disables peer verification.',
         'example' => '["secure.mycompany.com"]',
         'default' => array(),
       ),
       'browser' => array(
         'type' => 'string',
         'help' =>
           'Command to use to invoke a web browser.',
         'example' => '"gnome-www-browser"',
       ),
       'events.listeners' => array(
         'type' => 'list',
         'help' => 'List of event listener classes to install at startup.',
         'example' => '["ExampleEventListener"]',
         'default' => array(),
       ),
       'http.basicauth.user' => array(
         'type' => 'string',
         'help' =>
           'Username to use for basic auth over http transports',
         'example' => '"bob"',
       ),
       'http.basicauth.pass' => array(
         'type' => 'string',
         'help' =>
           'Password to use for basic auth over http transports',
         'example' => '"bobhasasecret"',
       ),
       'arc.autostash' => array(
         'type' => 'bool',
         'help' =>
           'Whether arc should permit the automatic stashing of changes in '.
-          'the working directory when requiring a clean working copy.  '.
+          'the working directory when requiring a clean working copy. '.
           'This option should only be used when users understand how '.
           'to restore their working directory from the local stash if '.
           'an Arcanist operation causes an unrecoverable error.',
         'example' => 'false',
         'default' => false,
       ),
     );
   }
 
   private function getOption($key) {
     return idx($this->getOptions(), $key, array());
   }
 
   public function getAllKeys() {
     return array_keys($this->getOptions());
   }
 
   public function getHelp($key) {
     return idx($this->getOption($key), 'help');
   }
 
   public function getExample($key) {
     return idx($this->getOption($key), 'example');
   }
 
   public function getType($key) {
     return idx($this->getOption($key), 'type', 'wild');
   }
 
   public function getLegacyName($key) {
     return idx($this->getOption($key), 'legacy');
   }
 
   public function getDefaultSettings() {
     $defaults = array();
     foreach ($this->getOptions() as $key => $option) {
       if (array_key_exists('default', $option)) {
         $defaults[$key] = $option['default'];
       }
     }
     return $defaults;
   }
 
   public function willWriteValue($key, $value) {
     $type = $this->getType($key);
     switch ($type) {
       case 'bool':
         if (strtolower($value) === 'false' ||
             strtolower($value) === 'no' ||
             strtolower($value) === 'off' ||
             $value === '' ||
             $value === '0' ||
             $value === 0 ||
             $value === false) {
           $value = false;
         } else if (strtolower($value) === 'true' ||
                    strtolower($value) === 'yes' ||
                    strtolower($value) === 'on' ||
                    $value === '1' ||
                    $value === 1 ||
                    $value === true) {
           $value = true;
         } else {
           throw new ArcanistUsageException(
             "Type of setting '{$key}' must be boolean, like 'true' or ".
             "'false'.");
         }
         break;
       case 'list':
         if (is_array($value)) {
           break;
         }
 
         if (is_string($value)) {
           $list = json_decode($value, true);
           if (is_array($list)) {
             $value = $list;
             break;
           }
         }
 
         $list_example = '["apple", "banana", "cherry"]';
         throw new ArcanistUsageException(
           "Type of setting '{$key}' must be list. You can specify a list ".
           "in JSON, like: {$list_example}");
 
       case 'string':
         if (!is_scalar($value)) {
           throw new ArcanistUsageException(
             "Type of setting '{$key}' must be string.");
         }
         $value = (string)$value;
         break;
       case 'wild':
         break;
     }
 
     return $value;
   }
 
   public function willReadValue($key, $value) {
     $type = $this->getType($key);
     switch ($type) {
       case 'string':
         if (!is_string($value)) {
           throw new ArcanistUsageException(
             "Type of setting '{$key}' must be string.");
         }
         break;
       case 'bool':
         if ($value !== true && $value !== false) {
           throw new ArcanistUsageException(
             "Type of setting '{$key}' must be boolean.");
         }
         break;
       case 'list':
         if (!is_array($value)) {
           throw new ArcanistUsageException(
             "Type of setting '{$key}' must be list.");
         }
         break;
       case 'wild':
         break;
     }
 
     return $value;
   }
 
   public function formatConfigValueForDisplay($key, $value) {
     if ($value === false) {
       return 'false';
     }
 
     if ($value === true) {
       return 'true';
     }
 
     if ($value === null) {
       return 'null';
     }
 
     if (is_string($value)) {
       return '"'.$value.'"';
     }
 
     if (is_array($value)) {
       // TODO: Both json_encode() and PhutilJSON do a bad job with one-liners.
       // PhutilJSON splits them across a bunch of lines, while json_encode()
       // escapes all kinds of stuff like "/". It would be nice if PhutilJSON
       // had a mode for pretty one-liners.
       $value = json_encode($value);
 
       // json_encode() unnecessarily escapes "/" to prevent "</script>" stuff,
       // optimistically unescape it for display to improve readability.
       $value = preg_replace('@(?<!\\\\)\\\\/@', '/', $value);
       return $value;
     }
 
     return $value;
   }
 
-
 }
diff --git a/src/configuration/__tests__/ArcanistBritishTestCase.php b/src/configuration/__tests__/ArcanistBritishTestCase.php
index 511614ff..8a5dde39 100644
--- a/src/configuration/__tests__/ArcanistBritishTestCase.php
+++ b/src/configuration/__tests__/ArcanistBritishTestCase.php
@@ -1,98 +1,97 @@
 <?php
 
 final class ArcanistBritishTestCase extends ArcanistTestCase {
 
   public function testCommandCompletion() {
     $this->assertCommandCompletion(
       array('land'),
       'alnd',
       array('land', 'amend'));
 
     $this->assertCommandCompletion(
       array('branch'),
       'brnach',
       array('branch', 'browse'));
 
     $this->assertCommandCompletion(
       array(),
       'test',
       array('list', 'unit'));
 
     $this->assertCommandCompletion(
       array('list'),
       'lists',
       array('list'));
 
     $this->assertCommandCompletion(
       array('diff'),
       'dfif',
       array('diff'));
 
     $this->assertCommandCompletion(
       array('unit'),
       'uint',
       array('unit', 'lint', 'list'));
 
     $this->assertCommandCompletion(
       array('list', 'lint'),
       'nilt',
       array('unit', 'lint', 'list'));
   }
 
   private function assertCommandCompletion($expect, $input, $commands) {
     $result = ArcanistConfiguration::correctCommandSpelling(
       $input,
       $commands,
       2);
 
     sort($result);
     sort($expect);
 
     $commands = implode(', ', $commands);
 
     $this->assertEqual(
       $expect,
       $result,
       "Correction of {$input} against: {$commands}");
   }
 
-
   public function testArgumentCompletion() {
     $this->assertArgumentCompletion(
       array('nolint'),
       'no-lint',
       array('nolint', 'nounit'));
 
     $this->assertArgumentCompletion(
       array('reviewers'),
       'reviewer',
       array('reviewers', 'cc'));
 
     $this->assertArgumentCompletion(
       array(),
       'onlint',
       array('nolint'));
 
     $this->assertArgumentCompletion(
       array(),
       'nolind',
       array('nolint'));
   }
 
   private function assertArgumentCompletion($expect, $input, $arguments) {
     $result = ArcanistConfiguration::correctArgumentSpelling(
       $input,
       $arguments);
 
     sort($result);
     sort($expect);
 
     $arguments = implode(', ', $arguments);
 
     $this->assertEqual(
       $expect,
       $result,
       "Correction of {$input} against: {$arguments}");
   }
 
 }
diff --git a/src/difference/ArcanistDiffUtils.php b/src/difference/ArcanistDiffUtils.php
index 4fdff267..2c89599e 100644
--- a/src/difference/ArcanistDiffUtils.php
+++ b/src/difference/ArcanistDiffUtils.php
@@ -1,256 +1,254 @@
 <?php
 
 /**
  * Dumping ground for diff- and diff-algorithm-related miscellany.
- *
- * @group diff
  */
 final class ArcanistDiffUtils {
 
   /**
    * Make a best-effort attempt to determine if a file is definitely binary.
    *
    * @return bool If true, the file is almost certainly binary. If false, the
    *              file might still be binary but is subtle about it.
    */
   public static function isHeuristicBinaryFile($data) {
     // Detect if a file is binary according to the Git heuristic, which is the
     // presence of NULL ("\0") bytes. Git only examines the first "few" bytes of
     // each file (8KB or so) as an optimization, but we don't have a reasonable
     // equivalent in PHP, so just look at all of it.
     return (strpos($data, "\0") !== false);
   }
 
   public static function renderDifferences(
     $old,
     $new,
     $context_lines = 3,
     $diff_options  = "-L 'Old Value' -L 'New Value'") {
 
     if ((string)$old === (string)$new) {
       $new .= "\n(Old and new values are identical.)";
     }
 
     $file_old = new TempFile();
     $file_new = new TempFile();
 
     Filesystem::writeFile($file_old, (string)$old."\n");
     Filesystem::writeFile($file_new, (string)$new."\n");
 
     list($err, $stdout) = exec_manual(
       'diff %C -U %s %s %s',
       $diff_options,
       $context_lines,
       $file_old,
       $file_new);
 
     return $stdout;
   }
 
   public static function generateIntralineDiff($o, $n) {
     $ol = strlen($o);
     $nl = strlen($n);
 
     if (($o === $n) || !$ol || !$nl) {
       return array(
         array(array(0, $ol)),
         array(array(0, $nl))
       );
     }
 
     return self::computeIntralineEdits($o, $n);
   }
 
   public static function applyIntralineDiff($str, $intra_stack) {
     $buf = '';
     $p = $s = $e = 0; // position, start, end
     $highlight = $tag = $ent = false;
     $highlight_o = '<span class="bright">';
     $highlight_c = '</span>';
 
     $is_html = false;
     if ($str instanceof PhutilSafeHTML) {
       $is_html = true;
       $str = $str->getHTMLContent();
     }
 
     $n = strlen($str);
     for ($i = 0; $i < $n; $i++) {
 
       if ($p == $e) {
         do {
           if (empty($intra_stack)) {
             $buf .= substr($str, $i);
             break 2;
           }
           $stack = array_shift($intra_stack);
           $s = $e;
           $e += $stack[1];
         } while ($stack[0] == 0);
       }
 
       if (!$highlight && !$tag && !$ent && $p == $s) {
         $buf .= $highlight_o;
         $highlight = true;
       }
 
       if ($str[$i] == '<') {
         $tag = true;
         if ($highlight) {
           $buf .= $highlight_c;
         }
       }
 
       if (!$tag) {
         if ($str[$i] == '&') {
           $ent = true;
         }
         if ($ent && $str[$i] == ';') {
           $ent = false;
         }
         if (!$ent) {
           $p++;
         }
       }
 
       $buf .= $str[$i];
 
       if ($tag && $str[$i] == '>') {
         $tag = false;
         if ($highlight) {
           $buf .= $highlight_o;
         }
       }
 
       if ($highlight && ($p == $e || $i == $n - 1)) {
         $buf .= $highlight_c;
         $highlight = false;
       }
     }
 
     if ($is_html) {
       return phutil_safe_html($buf);
     }
 
     return $buf;
   }
 
   private static function collapseIntralineRuns($runs) {
     $count = count($runs);
     for ($ii = 0; $ii < $count - 1; $ii++) {
       if ($runs[$ii][0] == $runs[$ii + 1][0]) {
         $runs[$ii + 1][1] += $runs[$ii][1];
         unset($runs[$ii]);
       }
     }
     return array_values($runs);
   }
 
   public static function generateEditString(array $ov, array $nv, $max = 80) {
     return id(new PhutilEditDistanceMatrix())
       ->setComputeString(true)
       ->setAlterCost(1 / ($max * 2))
       ->setReplaceCost(2)
       ->setMaximumLength($max)
       ->setSequences($ov, $nv)
       ->getEditString();
   }
 
   public static function computeIntralineEdits($o, $n) {
     if (preg_match('/[\x80-\xFF]/', $o.$n)) {
       $ov = phutil_utf8v_combined($o);
       $nv = phutil_utf8v_combined($n);
       $multibyte = true;
     } else {
       $ov = str_split($o);
       $nv = str_split($n);
       $multibyte = false;
     }
 
     $result = self::generateEditString($ov, $nv);
 
     // Smooth the string out, by replacing short runs of similar characters
     // with 'x' operations. This makes the result more readable to humans, since
     // there are fewer choppy runs of short added and removed substrings.
     do {
       $original = $result;
       $result = preg_replace(
         '/([xdi])(s{3})([xdi])/',
         '$1xxx$3',
         $result);
       $result = preg_replace(
         '/([xdi])(s{2})([xdi])/',
         '$1xx$3',
         $result);
       $result = preg_replace(
         '/([xdi])(s{1})([xdi])/',
         '$1x$3',
         $result);
     } while ($result != $original);
 
     // Now we have a character-based description of the edit. We need to
     // convert into a byte-based description. Walk through the edit string and
     // adjust each operation to reflect the number of bytes in the underlying
     // character.
 
     $o_pos = 0;
     $n_pos = 0;
     $result_len = strlen($result);
     $o_run = array();
     $n_run = array();
 
     $old_char_len = 1;
     $new_char_len = 1;
 
     for ($ii = 0; $ii < $result_len; $ii++) {
       $c = $result[$ii];
 
       if ($multibyte) {
         $old_char_len = strlen($ov[$o_pos]);
         $new_char_len = strlen($nv[$n_pos]);
       }
 
       switch ($c) {
         case 's':
         case 'x':
           $byte_o = $old_char_len;
           $byte_n = $new_char_len;
           $o_pos++;
           $n_pos++;
           break;
         case 'i':
           $byte_o = 0;
           $byte_n = $new_char_len;
           $n_pos++;
           break;
         case 'd':
           $byte_o = $old_char_len;
           $byte_n = 0;
           $o_pos++;
           break;
       }
 
       if ($byte_o) {
         if ($c == 's') {
           $o_run[] = array(0, $byte_o);
         } else {
           $o_run[] = array(1, $byte_o);
         }
       }
 
       if ($byte_n) {
         if ($c == 's') {
           $n_run[] = array(0, $byte_n);
         } else {
           $n_run[] = array(1, $byte_n);
         }
       }
     }
 
     $o_run = self::collapseIntralineRuns($o_run);
     $n_run = self::collapseIntralineRuns($n_run);
 
     return array($o_run, $n_run);
   }
 
 }
diff --git a/src/difference/__tests__/ArcanistDiffUtilsTestCase.php b/src/difference/__tests__/ArcanistDiffUtilsTestCase.php
index e07da6a4..d928e539 100644
--- a/src/difference/__tests__/ArcanistDiffUtilsTestCase.php
+++ b/src/difference/__tests__/ArcanistDiffUtilsTestCase.php
@@ -1,242 +1,242 @@
 <?php
 
 /**
  * Test cases for @{class:ArcanistDiffUtils}.
- *
- * @group testcase
  */
 final class ArcanistDiffUtilsTestCase extends ArcanistTestCase {
+
   public function testLevenshtein() {
     $tests = array(
       array(
         'a',
         'b',
-        'x'
+        'x',
       ),
       array(
         'kalrmr(array($b))',
         'array($b)',
-        'dddddddssssssssds'
+        'dddddddssssssssds',
       ),
       array(
         'array($b)',
         'kalrmr(array($b))',
-        'iiiiiiissssssssis'
+        'iiiiiiissssssssis',
       ),
       array(
         'zkalrmr(array($b))z',
         'xarray($b)x',
-        'dddddddxsssssssssdx'
+        'dddddddxsssssssssdx',
       ),
       array(
         'xarray($b)x',
         'zkalrmr(array($b))z',
-        'iiiiiiixsssssssssix'
+        'iiiiiiixsssssssssix',
       ),
       array(
         'abcdefghi',
         'abcdefghi',
-        'sssssssss'
+        'sssssssss',
       ),
       array(
         'abcdefghi',
         'abcdefghijkl',
-        'sssssssssiii'
+        'sssssssssiii',
       ),
       array(
         'abcdefghijkl',
         'abcdefghi',
-        'sssssssssddd'
+        'sssssssssddd',
       ),
       array(
         'xyzabcdefghi',
         'abcdefghi',
-        'dddsssssssss'
+        'dddsssssssss',
       ),
       array(
         'abcdefghi',
         'xyzabcdefghi',
-        'iiisssssssss'
+        'iiisssssssss',
       ),
       array(
         'abcdefg',
         'abxdxfg',
-        'ssxsxss'
+        'ssxsxss',
       ),
       array(
         'private function a($a, $b) {',
         'public function and($b, $c) {',
-        'siixsdddxsssssssssssiissxsssxsss'
+        'siixsdddxsssssssssssiissxsssxsss',
       ),
       array(
 
         // This is a test that we correctly detect shared prefixes and suffixes
         // and don't trigger "give up, too long" mode if there's a small text
         // change in an ocean of similar text.
 
         '        if ('.
           'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'.
           'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'.
           'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx) {',
         '        if('.
           'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'.
           'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'.
           'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx) {',
         'ssssssssssds'.
           'ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss'.
           'ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss'.
           'sssssssssssssssssssssssssssssssssssssss',
       ),
     );
 
     foreach ($tests as $test) {
       $this->assertEqual(
         $test[2],
         ArcanistDiffUtils::generateEditString(
           str_split($test[0]),
           str_split($test[1])),
         "'{$test[0]}' vs '{$test[1]}'");
     }
 
     $utf8_tests = array(
       array(
         'GrumpyCat',
         "Grumpy\xE2\x98\x83at",
         'ssssssxss',
       ),
     );
 
     foreach ($tests as $test) {
       $this->assertEqual(
         $test[2],
         ArcanistDiffUtils::generateEditString(
           phutil_utf8v_combined($test[0]),
           phutil_utf8v_combined($test[1])),
         "'{$test[0]}' vs '{$test[1]}' (utf8)");
     }
   }
 
   public function testGenerateUTF8IntralineDiff() {
     // Both Strings Empty.
     $left = '';
     $right = '';
     $result = array(
-                array(array(0, 0)),
-                array(array(0, 0))
-              );
+      array(array(0, 0)),
+      array(array(0, 0)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // Left String Empty.
     $left = '';
     $right = "Grumpy\xE2\x98\x83at";
     $result = array(
-                array(array(0, 0)),
-                array(array(0, 11))
-              );
+      array(array(0, 0)),
+      array(array(0, 11)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // Right String Empty.
     $left = "Grumpy\xE2\x98\x83at";
     $right = '';
     $result = array(
-                array(array(0, 11)),
-                array(array(0, 0))
-              );
+      array(array(0, 11)),
+      array(array(0, 0)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // Both Strings Same
     $left = "Grumpy\xE2\x98\x83at";
     $right = "Grumpy\xE2\x98\x83at";
     $result = array(
-                array(array(0, 11)),
-                array(array(0, 11))
-              );
+      array(array(0, 11)),
+      array(array(0, 11)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // Both Strings are different.
     $left = "Grumpy\xE2\x98\x83at";
     $right = 'Smiling Dog';
     $result = array(
-                array(array(1, 11)),
-                array(array(1, 11))
-              );
+      array(array(1, 11)),
+      array(array(1, 11)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // String with one difference in the middle.
     $left = 'GrumpyCat';
     $right = "Grumpy\xE2\x98\x83at";
     $result = array(
-                array(array(0, 6), array(1, 1), array(0, 2)),
-                array(array(0, 6), array(1, 3), array(0, 2))
-              );
+      array(array(0, 6), array(1, 1), array(0, 2)),
+      array(array(0, 6), array(1, 3), array(0, 2)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // Differences in middle, not connected to each other.
     $left = 'GrumpyCat';
     $right = "Grumpy\xE2\x98\x83a\xE2\x98\x83t";
     $result = array(
-                array(array(0, 6), array(1, 2), array(0, 1)),
-                array(array(0, 6), array(1, 7), array(0, 1))
-              );
+      array(array(0, 6), array(1, 2), array(0, 1)),
+      array(array(0, 6), array(1, 7), array(0, 1)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // String with difference at the beginning.
     $left = "GrumpyC\xE2\x98\x83t";
     $right = "DrumpyC\xE2\x98\x83t";
     $result = array(
-                array(array(1, 1), array(0, 10)),
-                array(array(1, 1), array(0, 10))
-              );
+      array(array(1, 1), array(0, 10)),
+      array(array(1, 1), array(0, 10)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // String with difference at the end.
     $left = "GrumpyC\xE2\x98\x83t";
     $right = "GrumpyC\xE2\x98\x83P";
     $result = array(
-                array(array(0, 10), array(1, 1)),
-                array(array(0, 10), array(1, 1))
-              );
+      array(array(0, 10), array(1, 1)),
+      array(array(0, 10), array(1, 1)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // String with differences at the beginning and end.
     $left = "GrumpyC\xE2\x98\x83t";
     $right = "DrumpyC\xE2\x98\x83P";
     $result = array(
-                array(array(1, 1), array(0, 9), array(1, 1)),
-                array(array(1, 1), array(0, 9), array(1, 1))
-              );
+      array(array(1, 1), array(0, 9), array(1, 1)),
+      array(array(1, 1), array(0, 9), array(1, 1)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
 
     // This is a unicode combining character, "COMBINING DOUBLE TILDE".
     $cc = "\xCD\xA0";
     $left = 'Senor';
     $right = "Sen{$cc}or";
     $result = array(
-                array(array(0, 2), array(1, 1), array(0, 2)),
-                array(array(0, 2), array(1, 3), array(0, 2))
-              );
+      array(array(0, 2), array(1, 1), array(0, 2)),
+      array(array(0, 2), array(1, 3), array(0, 2)),
+    );
     $this->assertEqual(
       $result,
       ArcanistDiffUtils::generateIntralineDiff($left, $right));
   }
+
 }
diff --git a/src/differential/ArcanistDifferentialCommitMessage.php b/src/differential/ArcanistDifferentialCommitMessage.php
index 4381556b..ab0d49c1 100644
--- a/src/differential/ArcanistDifferentialCommitMessage.php
+++ b/src/differential/ArcanistDifferentialCommitMessage.php
@@ -1,114 +1,112 @@
 <?php
 
 /**
  * Represents a parsed commit message.
- *
- * @group differential
  */
 final class ArcanistDifferentialCommitMessage {
 
   private $rawCorpus;
   private $revisionID;
   private $fields = array();
 
   private $gitSVNBaseRevision;
   private $gitSVNBasePath;
   private $gitSVNUUID;
 
   public static function newFromRawCorpus($corpus) {
     $obj = new ArcanistDifferentialCommitMessage();
     $obj->rawCorpus = $corpus;
 
     $match = null;
     if (preg_match('/^Differential Revision:\s*(.*)/im', $corpus, $match)) {
       $revision_id = trim($match[1]);
       if (strlen($revision_id)) {
         $uri = new PhutilURI($revision_id);
         $path = $uri->getPath();
         $path = trim($path, '/');
         if (preg_match('/^D\d+$/', $path)) {
           $obj->revisionID = (int)trim($path, 'D');
         } else {
           throw new ArcanistUsageException(
             "Invalid 'Differential Revision' field. The field should have a ".
             "Phabricator URI like 'http://phabricator.example.com/D123', ".
             "but has '{$match[1]}'.");
         }
       }
     }
 
     $pattern = '/^git-svn-id:\s*([^@]+)@(\d+)\s+(.*)$/m';
     if (preg_match($pattern, $corpus, $match)) {
       $obj->gitSVNBaseRevision = $match[1].'@'.$match[2];
       $obj->gitSVNBasePath     = $match[1];
       $obj->gitSVNUUID         = $match[3];
     }
 
     return $obj;
   }
 
   public function getRawCorpus() {
     return $this->rawCorpus;
   }
 
   public function getRevisionID() {
     return $this->revisionID;
   }
 
   public function pullDataFromConduit(
     ConduitClient $conduit,
     $partial = false) {
 
     $result = $conduit->callMethodSynchronous(
       'differential.parsecommitmessage',
       array(
         'corpus'  => $this->rawCorpus,
         'partial' => $partial,
       ));
 
     $this->fields = $result['fields'];
 
     if (!empty($result['errors'])) {
       throw new ArcanistDifferentialCommitMessageParserException(
         $result['errors']);
     }
 
     return $this;
   }
 
   public function getFieldValue($key) {
     if (array_key_exists($key, $this->fields)) {
       return $this->fields[$key];
     }
     return null;
   }
 
   public function setFieldValue($key, $value) {
     $this->fields[$key] = $value;
     return $this;
   }
 
   public function getFields() {
     return $this->fields;
   }
 
   public function getGitSVNBaseRevision() {
     return $this->gitSVNBaseRevision;
   }
 
   public function getGitSVNBasePath() {
     return $this->gitSVNBasePath;
   }
 
   public function getGitSVNUUID() {
     return $this->gitSVNUUID;
   }
 
   public function getChecksum() {
     $fields = array_filter($this->fields);
     ksort($fields);
     $fields = json_encode($fields);
     return md5($fields);
   }
 
 }
diff --git a/src/differential/ArcanistDifferentialCommitMessageParserException.php b/src/differential/ArcanistDifferentialCommitMessageParserException.php
index 680811dc..5227b021 100644
--- a/src/differential/ArcanistDifferentialCommitMessageParserException.php
+++ b/src/differential/ArcanistDifferentialCommitMessageParserException.php
@@ -1,21 +1,19 @@
 <?php
 
 /**
  * Thrown when a commit message isn't parseable.
- *
- * @group differential
  */
 final class ArcanistDifferentialCommitMessageParserException extends Exception {
 
   private $parserErrors;
 
   public function __construct(array $errors) {
     $this->parserErrors = $errors;
     parent::__construct(head($errors));
   }
 
   public function getParserErrors() {
     return $this->parserErrors;
   }
 
 }
diff --git a/src/events/constant/ArcanistEventType.php b/src/events/constant/ArcanistEventType.php
index 8c988dbd..d42dd4a4 100644
--- a/src/events/constant/ArcanistEventType.php
+++ b/src/events/constant/ArcanistEventType.php
@@ -1,15 +1,16 @@
 <?php
 
 final class ArcanistEventType extends PhutilEventType {
 
   const TYPE_COMMIT_WILLCOMMITSVN   = 'commit.willCommitSVN';
 
   const TYPE_DIFF_DIDCOLLECTCHANGES = 'diff.didCollectChanges';
   const TYPE_DIFF_WILLBUILDMESSAGE  = 'diff.willBuildMessage';
   const TYPE_DIFF_DIDBUILDMESSAGE   = 'diff.didBuildMessage';
   const TYPE_DIFF_WASCREATED        = 'diff.wasCreated';
 
   const TYPE_REVISION_WILLCREATEREVISION = 'revision.willCreateRevision';
 
   const TYPE_LAND_WILLPUSHREVISION  = 'land.willPushRevision';
+
 }
diff --git a/src/exception/ArcanistChooseInvalidRevisionException.php b/src/exception/ArcanistChooseInvalidRevisionException.php
index 9c1b2893..00ace326 100644
--- a/src/exception/ArcanistChooseInvalidRevisionException.php
+++ b/src/exception/ArcanistChooseInvalidRevisionException.php
@@ -1,10 +1,6 @@
 <?php
 
 /**
  * Thrown when the user chooses an invalid revision when prompted by a workflow.
- *
- * @group workflow
  */
-final class ArcanistChooseInvalidRevisionException extends Exception {
-
-}
+final class ArcanistChooseInvalidRevisionException extends Exception {}
diff --git a/src/exception/ArcanistChooseNoRevisionsException.php b/src/exception/ArcanistChooseNoRevisionsException.php
index 562d910e..708ae03e 100644
--- a/src/exception/ArcanistChooseNoRevisionsException.php
+++ b/src/exception/ArcanistChooseNoRevisionsException.php
@@ -1,11 +1,7 @@
 <?php
 
 /**
  * Thrown when there are no valid revisions to choose from, in a workflow which
  * prompts the user to choose a revision.
- *
- * @group workflow
  */
-final class ArcanistChooseNoRevisionsException extends Exception {
-
-}
+final class ArcanistChooseNoRevisionsException extends Exception {}
diff --git a/src/exception/ArcanistUsageException.php b/src/exception/ArcanistUsageException.php
index 8a8c31f6..2938e95f 100644
--- a/src/exception/ArcanistUsageException.php
+++ b/src/exception/ArcanistUsageException.php
@@ -1,12 +1,9 @@
 <?php
 
 /**
  * Thrown when there is a problem with how a user is invoking a command, rather
  * than a technical problem.
  *
- * @group workflow
  * @concrete-extensible
  */
-class ArcanistUsageException extends Exception {
-
-}
+class ArcanistUsageException extends Exception {}
diff --git a/src/exception/usage/ArcanistNoEffectException.php b/src/exception/usage/ArcanistNoEffectException.php
index 8a2e3201..9c35abd8 100644
--- a/src/exception/usage/ArcanistNoEffectException.php
+++ b/src/exception/usage/ArcanistNoEffectException.php
@@ -1,10 +1,7 @@
 <?php
 
 /**
  * Thrown when lint or unit tests have no effect, i.e. no paths are affected
  * by any linter or no unit tests provide coverage.
- *
- * @group workflow
  */
-final class ArcanistNoEffectException extends ArcanistUsageException {
-}
+final class ArcanistNoEffectException extends ArcanistUsageException {}
diff --git a/src/exception/usage/ArcanistNoEngineException.php b/src/exception/usage/ArcanistNoEngineException.php
index b9ddb129..61c6c7e4 100644
--- a/src/exception/usage/ArcanistNoEngineException.php
+++ b/src/exception/usage/ArcanistNoEngineException.php
@@ -1,9 +1,6 @@
 <?php
 
 /**
  * Thrown when no engine is configured for linting or running unit tests.
- *
- * @group workflow
  */
-final class ArcanistNoEngineException extends ArcanistUsageException {
-}
+final class ArcanistNoEngineException extends ArcanistUsageException {}
diff --git a/src/exception/usage/ArcanistUserAbortException.php b/src/exception/usage/ArcanistUserAbortException.php
index 02b9daf1..d1aa1ee1 100644
--- a/src/exception/usage/ArcanistUserAbortException.php
+++ b/src/exception/usage/ArcanistUserAbortException.php
@@ -1,13 +1,13 @@
 <?php
 
 /**
  * Thrown when the user chooses not to continue when warned that they're about
  * to do something dangerous.
- *
- * @group workflow
  */
 final class ArcanistUserAbortException extends ArcanistUsageException {
+
   public function __construct() {
     parent::__construct('User aborted the workflow.');
   }
+
 }
diff --git a/src/hgdaemon/ArcanistHgProxyClient.php b/src/hgdaemon/ArcanistHgProxyClient.php
index 3fb1af78..509c4254 100644
--- a/src/hgdaemon/ArcanistHgProxyClient.php
+++ b/src/hgdaemon/ArcanistHgProxyClient.php
@@ -1,198 +1,197 @@
 <?php
 
-
 /**
  * Client for an @{class:ArcanistHgProxyServer}. This client talks to a PHP
  * process which serves as a proxy in front of a Mercurial server process.
  * The PHP proxy allows multiple clients to use the same Mercurial server.
  *
  * This class presents an API which is similar to the hg command-line API.
  *
  * Each client is bound to a specific working copy:
  *
  *   $working_copy = '/path/to/some/hg/working/copy/';
  *   $client = new ArcanistHgProxyClient($working_copy);
  *
  * For example, to run `hg log -l 5` via a client:
  *
  *   $command = array('log', '-l', '5');
  *   list($err, $stdout, $stderr) = $client->executeCommand($command);
  *
  * The advantage of using this complex mechanism is that commands run in this
  * way do not need to pay the startup overhead for hg and the Python runtime,
  * which is often on the order of 100ms or more per command.
  *
  * @task construct  Construction
  * @task config     Configuration
  * @task exec       Executing Mercurial Commands
  * @task internal   Internals
  */
 final class ArcanistHgProxyClient {
 
   private $workingCopy;
   private $server;
 
   private $skipHello;
 
 
 /* -(  Construction  )------------------------------------------------------- */
 
 
   /**
    * Build a new client. This client is bound to a working copy. A server
    * must already be running on this working copy for the client to work.
    *
    * @param string Path to a Mercurial working copy.
    *
    * @task construct
    */
   public function __construct($working_copy) {
     $this->workingCopy = Filesystem::resolvePath($working_copy);
   }
 
 
 /* -(  Configuration  )------------------------------------------------------ */
 
 
   /**
    * When connecting, do not expect the "capabilities" message.
    *
    * @param bool True to skip the "capabilities" message.
    * @return this
    *
    * @task config
    */
   public function setSkipHello($skip) {
     $this->skipHello = $skip;
     return $this;
   }
 
 
 /* -(  Executing Merucurial Commands  )-------------------------------------- */
 
 
   /**
    * Execute a command (given as a list of arguments) via the command server.
    *
    * @param list<string> A list of command arguments, like "log", "-l", "5".
    * @return tuple<int, string, string> Return code, stdout and stderr.
    *
    * @task exec
    */
   public function executeCommand(array $argv) {
     if (!$this->server) {
 
       try {
         $server = $this->connectToDaemon();
       } catch (Exception $ex) {
         $this->launchDaemon();
         $server = $this->connectToDaemon();
       }
 
       $this->server = $server;
     }
     $server = $this->server;
 
     // Note that we're adding "runcommand" to make the server run the command.
     // Theoretically the server supports other capabilities, but in practice
     // we are only concerend with "runcommand".
 
     $server->write(array_merge(array('runcommand'), $argv));
 
     // We'll get back one or more blocks of response data, ending with an 'r'
     // block which indicates the return code. Reconstitute these into stdout,
     // stderr and a return code.
 
     $stdout = '';
     $stderr = '';
     $err    = 0;
 
     $done = false;
     while ($message = $server->waitForMessage()) {
 
       // The $server channel handles decoding of the wire format and gives us
       // messages which look like this:
       //
       //   array('o', '<data...>');
 
       list($channel, $data) = $message;
       switch ($channel) {
         case 'o':
           $stdout .= $data;
           break;
         case 'e':
           $stderr .= $data;
           break;
         case 'd':
           // TODO: Do something with this? This is the 'debug' channel.
           break;
         case 'r':
           // NOTE: This little dance is because the value is emitted as a
           // big-endian signed 32-bit long. PHP has no flag to unpack() that
           // can unpack these, so we unpack a big-endian unsigned long, then
           // repack it as a machine-order unsigned long, then unpack it as
           // a machine-order signed long. This appears to produce the desired
           // result.
           $err = head(unpack('N', $data));
           $err = pack('L', $err);
           $err = head(unpack('l', $err));
           $done = true;
           break;
       }
 
       if ($done) {
         break;
       }
     }
 
     return array($err, $stdout, $stderr);
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * @task internal
    */
   private function connectToDaemon() {
     $errno = null;
     $errstr = null;
 
     $socket_path = ArcanistHgProxyServer::getPathToSocket($this->workingCopy);
     $socket = @stream_socket_client('unix://'.$socket_path, $errno, $errstr);
 
     if ($errno || !$socket) {
       throw new Exception(
         "Unable to connect socket! Error #{$errno}: {$errstr}");
     }
 
     $channel = new PhutilSocketChannel($socket);
     $server = new ArcanistHgServerChannel($channel);
 
     if (!$this->skipHello) {
       // The protocol includes a "hello" message with capability and encoding
       // information. Read and discard it, we use only the "runcommand"
       // capability which is guaranteed to be available.
       $hello = $server->waitForMessage();
     }
 
     return $server;
   }
 
 
   /**
    * @task internal
    */
   private function launchDaemon() {
     $root = dirname(phutil_get_library_root('arcanist'));
     $bin = $root.'/scripts/hgdaemon/hgdaemon_server.php';
     $proxy = new ExecFuture(
       '%s %s --idle-limit 15 --quiet %C',
       $bin,
       $this->workingCopy,
       $this->skipHello ? '--skip-hello' : null);
     $proxy->resolvex();
   }
 
 }
diff --git a/src/hgdaemon/ArcanistHgProxyServer.php b/src/hgdaemon/ArcanistHgProxyServer.php
index 2cef30eb..aa7a7402 100644
--- a/src/hgdaemon/ArcanistHgProxyServer.php
+++ b/src/hgdaemon/ArcanistHgProxyServer.php
@@ -1,487 +1,486 @@
 <?php
 
 /**
  * Server which @{class:ArcanistHgProxyClient} clients connect to. This
  * server binds to a Mercurial working copy and creates a Mercurial process and
  * a unix domain socket in that working copy. It listens for connections on
  * the socket, reads commands from them, and forwards their requests to the
  * Mercurial process. It then returns responses to the original clients.
  *
  * Note that this server understands the underlying protocol and completely
  * decodes messages from both the client and server before re-encoding them
  * and relaying them to their final destinations. It must do this (at least
  * in part) to determine where messages begin and end. Additionally, this proxy
  * sends and receives the Mercurial cmdserver protocol exactly, without
  * any extensions or sneakiness.
  *
  * The advantage of this mechanism is that it avoids the overhead of starting
  * a Mercurial process for each Mercurial command, which can exceed 100ms per
  * invocation. This server can also accept connections from multiple clients
  * and serve them from a single Mercurial server process.
  *
  * @task construct  Construction
  * @task config     Configuration
  * @task server     Serving Requests
  * @task client     Managing Clients
  * @task hg         Managing Mercurial
  * @task internal   Internals
  */
 final class ArcanistHgProxyServer {
 
   private $workingCopy;
   private $socket;
   private $hello;
 
   private $quiet;
 
   private $clientLimit;
   private $lifetimeClientCount;
 
   private $idleLimit;
   private $idleSince;
 
   private $skipHello;
 
   private $doNotDaemonize;
 
 
 /* -(  Construction  )------------------------------------------------------- */
 
 
   /**
    * Build a new server. This server is bound to a working copy. The server
    * is inactive until you @{method:start} it.
    *
    * @param string Path to a Mercurial working copy.
    *
    * @task construct
    */
   public function __construct($working_copy) {
     $this->workingCopy = Filesystem::resolvePath($working_copy);
   }
 
 
 /* -(  Configuration  )------------------------------------------------------ */
 
 
   /**
    * Disable status messages to stdout. Controlled with `--quiet`.
    *
    * @param bool  True to disable status messages.
    * @return this
    *
    * @task config
    */
   public function setQuiet($quiet) {
     $this->quiet = $quiet;
     return $this;
   }
 
 
   /**
    * Configure a client limit. After serving this many clients, the server
    * will exit. Controlled with `--client-limit`.
    *
    * You can use `--client-limit 1` with `--xprofile` and `--do-not-daemonize`
    * to profile the server.
    *
    * @param int Client limit, or 0 to disable limit.
    * @return this
    *
    * @task config
    */
   public function setClientLimit($limit) {
     $this->clientLimit = $limit;
     return $this;
   }
 
 
   /**
    * Configure an idle time limit. After this many seconds idle, the server
    * will exit. Controlled with `--idle-limit`.
    *
    * @param int Idle limit, or 0 to disable limit.
    * @return this
    *
    * @task config
    */
   public function setIdleLimit($limit) {
     $this->idleLimit = $limit;
     return $this;
   }
 
 
   /**
    * When clients connect, do not send the "capabilities" message expected by
    * the Mercurial protocol. This deviates from the protocol and will only work
    * if the clients are also configured not to expect the message, but slightly
    * improves performance. Controlled with --skip-hello.
    *
    * @param bool True to skip the "capabilities" message.
    * @return this
    *
    * @task config
    */
   public function setSkipHello($skip) {
     $this->skipHello = $skip;
     return $this;
   }
 
 
   /**
    * Configure whether the server runs in the foreground or daemonizes.
    * Controlled by --do-not-daemonize. Primarily useful for debugging.
    *
    * @param bool True to run in the foreground.
    * @return this
    *
    * @task config
    */
   public function setDoNotDaemonize($do_not_daemonize) {
     $this->doNotDaemonize = $do_not_daemonize;
     return $this;
   }
 
 
 /* -(  Serving Requests  )--------------------------------------------------- */
 
 
   /**
    * Start the server. This method returns after the client limit or idle
    * limit are exceeded. If neither limit is configured, this method does not
    * exit.
    *
    * @return null
    *
    * @task server
    */
   public function start() {
     // Create the unix domain socket in the working copy to listen for clients.
     $socket = $this->startWorkingCopySocket();
     $this->socket = $socket;
 
     if (!$this->doNotDaemonize) {
       $this->daemonize();
     }
 
     // Start the Mercurial process which we'll forward client requests to.
     $hg = $this->startMercurialProcess();
     $clients = array();
 
     $this->log(null, 'Listening');
     $this->idleSince = time();
     while (true) {
       // Wait for activity on any active clients, the Mercurial process, or
       // the listening socket where new clients connect.
       PhutilChannel::waitForAny(
         array_merge($clients, array($hg)),
         array(
           'read'    => $socket ? array($socket) : array(),
           'except'  => $socket ? array($socket) : array()
         ));
 
       if (!$hg->update()) {
         throw new Exception('Server exited unexpectedly!');
       }
 
       // Accept any new clients.
       while ($socket && ($client = $this->acceptNewClient($socket))) {
         $clients[] = $client;
         $key = last_key($clients);
         $client->setName($key);
 
         $this->log($client, 'Connected');
         $this->idleSince = time();
 
         // Check if we've hit the client limit. If there's a configured
         // client limit and we've hit it, stop accepting new connections
         // and close the socket.
 
         $this->lifetimeClientCount++;
 
         if ($this->clientLimit) {
           if ($this->lifetimeClientCount >= $this->clientLimit) {
             $this->closeSocket();
             $socket = null;
           }
         }
       }
 
       // Update all the active clients.
       foreach ($clients as $key => $client) {
         if ($this->updateClient($client, $hg)) {
           // In this case, the client is still connected so just move on to
           // the next one. Otherwise we continue below and handle the disconect.
           continue;
         }
 
         $this->log($client, 'Disconnected');
         unset($clients[$key]);
 
         // If we have a client limit and we've served that many clients, exit.
 
         if ($this->clientLimit) {
           if ($this->lifetimeClientCount >= $this->clientLimit) {
             if (!$clients) {
               $this->log(null, 'Exiting (Client Limit)');
               return;
             }
           }
         }
       }
 
       // If we have an idle limit and haven't had any activity in at least
       // that long, exit.
       if ($this->idleLimit) {
         $remaining = $this->idleLimit - (time() - $this->idleSince);
         if ($remaining <= 0) {
           $this->log(null, 'Exiting (Idle Limit)');
           return;
         }
         if ($remaining <= 5) {
           $this->log(null, 'Exiting in '.$remaining.' seconds');
         }
       }
     }
   }
 
 
   /**
    * Update one client, processing any commands it has sent us. We fully
    * process all commands we've received here before returning to the main
    * server loop.
    *
    * @param ArcanistHgClientChannel The client to update.
    * @param ArcanistHgServerChannel The Mercurial server.
    *
    * @task server
    */
   private function updateClient(
     ArcanistHgClientChannel $client,
     ArcanistHgServerChannel $hg) {
 
     if (!$client->update()) {
       // Client has disconnected, don't bother proceeding.
       return false;
     }
 
     // Read a command from the client if one is available. Note that we stop
     // updating other clients or accepting new connections while processing a
     // command, since there isn't much we can do with them until the server
     // finishes executing this command.
     $message = $client->read();
     if (!$message) {
       return true;
     }
 
     $this->log($client, '$ '.$message[0].' '.$message[1]);
     $t_start = microtime(true);
 
     // Forward the command to the server.
     $hg->write($message);
 
     while (true) {
       PhutilChannel::waitForAny(array($client, $hg));
 
       if (!$client->update() || !$hg->update()) {
         // If either the client or server has exited, bail.
         return false;
       }
 
       $response = $hg->read();
       if (!$response) {
         continue;
       }
 
       // Forward the response back to the client.
       $client->write($response);
 
       // If the response was on the 'r'esult channel, it indicates the end
       // of the command output. We can process the next command (if any
       // remain) or go back to accepting new connections and servicing
       // other clients.
       if ($response[0] == 'r') {
         // Update the client immediately to try to get the bytes on the wire
         // as quickly as possible. This gives us slightly more throughput.
         $client->update();
         break;
       }
     }
 
     // Log the elapsed time.
     $t_end = microtime(true);
     $t = 1000000 * ($t_end - $t_start);
     $this->log($client, '< '.number_format($t, 0).'us');
 
     $this->idleSince = time();
 
     return true;
   }
 
 
 /* -(  Managing Clients  )--------------------------------------------------- */
 
 
   /**
    * @task client
    */
   public static function getPathToSocket($working_copy) {
     return $working_copy.'/.hg/hgdaemon-socket';
   }
 
 
   /**
    * @task client
    */
   private function startWorkingCopySocket() {
     $errno = null;
     $errstr = null;
 
     $socket_path = self::getPathToSocket($this->workingCopy);
     $socket_uri  = 'unix://'.$socket_path;
 
     $socket = @stream_socket_server($socket_uri, $errno, $errstr);
     if ($errno || !$socket) {
       Filesystem::remove($socket_path);
       $socket = @stream_socket_server($socket_uri, $errno, $errstr);
     }
 
     if ($errno || !$socket) {
       throw new Exception(
         "Unable to start socket! Error #{$errno}: {$errstr}");
     }
 
     $ok = stream_set_blocking($socket, 0);
     if ($ok === false) {
       throw new Exception('Unable to set socket nonblocking!');
     }
 
     return $socket;
   }
 
 
   /**
    * @task client
    */
   private function acceptNewClient($socket) {
     // NOTE: stream_socket_accept() always blocks, even when the socket has
     // been set nonblocking.
     $new_client = @stream_socket_accept($socket, $timeout = 0);
     if (!$new_client) {
       return null;
     }
 
     $channel = new PhutilSocketChannel($new_client);
     $client = new ArcanistHgClientChannel($channel);
 
     if (!$this->skipHello) {
       $client->write($this->hello);
     }
 
     return $client;
   }
 
 
 /* -(  Managing Mercurial  )------------------------------------------------- */
 
 
   /**
    * Starts a Mercurial process which can actually handle requests.
    *
    * @return ArcanistHgServerChannel  Channel to the Mercurial server.
    * @task hg
    */
   private function startMercurialProcess() {
     // NOTE: "cmdserver.log=-" makes Mercurial use the 'd'ebug channel for
     // log messages.
 
     $future = new ExecFuture(
       'HGPLAIN=1 hg --config cmdserver.log=- serve --cmdserver pipe');
     $future->setCWD($this->workingCopy);
 
     $channel = new PhutilExecChannel($future);
     $hg = new ArcanistHgServerChannel($channel);
 
     // The server sends a "hello" message with capability and encoding
     // information. Save it and forward it to clients when they connect.
     $this->hello = $hg->waitForMessage();
 
     return $hg;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Close and remove the unix domain socket in the working copy.
    *
    * @task internal
    */
   public function __destruct() {
     $this->closeSocket();
   }
 
   private function closeSocket() {
     if ($this->socket) {
       @stream_socket_shutdown($this->socket, STREAM_SHUT_RDWR);
       @fclose($this->socket);
       Filesystem::remove(self::getPathToSocket($this->workingCopy));
       $this->socket = null;
     }
   }
 
   private function log($client, $message) {
     if ($this->quiet) {
       return;
     }
 
     if ($client) {
       $message = '[Client '.$client->getName().'] '.$message;
     } else {
       $message = '[Server] '.$message;
     }
 
     echo $message."\n";
   }
 
   private function daemonize() {
-
     // Keep stdout if it's been redirected somewhere, otherwise shut it down.
     $keep_stdout = false;
     $keep_stderr = false;
     if (function_exists('posix_isatty')) {
       if (!posix_isatty(STDOUT)) {
         $keep_stdout = true;
       }
       if (!posix_isatty(STDERR)) {
         $keep_stderr = true;
       }
     }
 
     $pid = pcntl_fork();
     if ($pid === -1) {
       throw new Exception('Unable to fork!');
     } else if ($pid) {
       // We're the parent; exit. First, drop our reference to the socket so
       // our __destruct() doesn't tear it down; the child will tear it down
       // later.
       $this->socket = null;
       exit(0);
     }
 
     // We're the child; continue.
 
     fclose(STDIN);
 
     if (!$keep_stdout) {
       fclose(STDOUT);
       $this->quiet = true;
     }
 
     if (!$keep_stderr) {
       fclose(STDERR);
     }
   }
 
 }
diff --git a/src/lint/ArcanistLintMessage.php b/src/lint/ArcanistLintMessage.php
index 80816fbb..8996c992 100644
--- a/src/lint/ArcanistLintMessage.php
+++ b/src/lint/ArcanistLintMessage.php
@@ -1,230 +1,228 @@
 <?php
 
 /**
  * Message emitted by a linter, like an error or warning.
- *
- * @group lint
  */
 final class ArcanistLintMessage {
 
   protected $path;
   protected $line;
   protected $char;
   protected $code;
   protected $severity;
   protected $name;
   protected $description;
   protected $originalText;
   protected $replacementText;
   protected $appliedToDisk;
   protected $dependentMessages = array();
   protected $otherLocations = array();
   protected $obsolete;
   protected $granularity;
   protected $bypassChangedLineFiltering;
 
   public static function newFromDictionary(array $dict) {
     $message = new ArcanistLintMessage();
 
     $message->setPath($dict['path']);
     $message->setLine($dict['line']);
     $message->setChar($dict['char']);
     $message->setCode($dict['code']);
     $message->setSeverity($dict['severity']);
     $message->setName($dict['name']);
     $message->setDescription($dict['description']);
     if (isset($dict['original'])) {
       $message->setOriginalText($dict['original']);
     }
     if (isset($dict['replacement'])) {
       $message->setReplacementText($dict['replacement']);
     }
     $message->setGranularity(idx($dict, 'granularity'));
     $message->setOtherLocations(idx($dict, 'locations', array()));
     if (isset($dict['bypassChangedLineFiltering'])) {
       $message->bypassChangedLineFiltering($dict['bypassChangedLineFiltering']);
     }
     return $message;
   }
 
   public function toDictionary() {
     return array(
       'path'        => $this->getPath(),
       'line'        => $this->getLine(),
       'char'        => $this->getChar(),
       'code'        => $this->getCode(),
       'severity'    => $this->getSeverity(),
       'name'        => $this->getName(),
       'description' => $this->getDescription(),
       'original'    => $this->getOriginalText(),
       'replacement' => $this->getReplacementText(),
       'granularity' => $this->getGranularity(),
       'locations'   => $this->getOtherLocations(),
       'bypassChangedLineFiltering' => $this->shouldBypassChangedLineFiltering(),
     );
   }
 
   public function setPath($path) {
     $this->path = $path;
     return $this;
   }
 
   public function getPath() {
     return $this->path;
   }
 
   public function setLine($line) {
     $this->line = $line;
     return $this;
   }
 
   public function getLine() {
     return $this->line;
   }
 
   public function setChar($char) {
     $this->char = $char;
     return $this;
   }
 
   public function getChar() {
     return $this->char;
   }
 
   public function setCode($code) {
     $this->code = $code;
     return $this;
   }
 
   public function getCode() {
     return $this->code;
   }
 
   public function setSeverity($severity) {
     $this->severity = $severity;
     return $this;
   }
 
   public function getSeverity() {
     return $this->severity;
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function setDescription($description) {
     $this->description = $description;
     return $this;
   }
 
   public function getDescription() {
     return $this->description;
   }
 
   public function setOriginalText($original) {
     $this->originalText = $original;
     return $this;
   }
 
   public function getOriginalText() {
     return $this->originalText;
   }
 
   public function setReplacementText($replacement) {
     $this->replacementText = $replacement;
     return $this;
   }
 
   public function getReplacementText() {
     return $this->replacementText;
   }
 
   /**
    * @param dict Keys 'path', 'line', 'char', 'original'.
    */
   public function setOtherLocations(array $locations) {
     assert_instances_of($locations, 'array');
     $this->otherLocations = $locations;
     return $this;
   }
 
   public function getOtherLocations() {
     return $this->otherLocations;
   }
 
   public function isError() {
     return $this->getSeverity() == ArcanistLintSeverity::SEVERITY_ERROR;
   }
 
   public function isWarning() {
     return $this->getSeverity() == ArcanistLintSeverity::SEVERITY_WARNING;
   }
 
   public function isAutofix() {
     return $this->getSeverity() == ArcanistLintSeverity::SEVERITY_AUTOFIX;
   }
 
   public function hasFileContext() {
     return ($this->getLine() !== null);
   }
 
   public function setObsolete($obsolete) {
     $this->obsolete = $obsolete;
     return $this;
   }
 
   public function getObsolete() {
     return $this->obsolete;
   }
 
   public function isPatchable() {
     return ($this->getReplacementText() !== null) &&
            ($this->getReplacementText() !== $this->getOriginalText());
   }
 
   public function didApplyPatch() {
     if ($this->appliedToDisk) {
       return $this;
     }
     $this->appliedToDisk = true;
     foreach ($this->dependentMessages as $message) {
       $message->didApplyPatch();
     }
     return $this;
   }
 
   public function isPatchApplied() {
     return $this->appliedToDisk;
   }
 
   public function setGranularity($granularity) {
     $this->granularity = $granularity;
     return $this;
   }
 
   public function getGranularity() {
     return $this->granularity;
   }
 
   public function setDependentMessages(array $messages) {
     assert_instances_of($messages, 'ArcanistLintMessage');
     $this->dependentMessages = $messages;
     return $this;
   }
 
   public function setBypassChangedLineFiltering($bypass_changed_lines) {
     $this->bypassChangedLineFiltering = $bypass_changed_lines;
     return $this;
   }
 
   public function shouldBypassChangedLineFiltering() {
     return $this->bypassChangedLineFiltering;
   }
 
 }
diff --git a/src/lint/ArcanistLintPatcher.php b/src/lint/ArcanistLintPatcher.php
index 51639d3e..7d22b240 100644
--- a/src/lint/ArcanistLintPatcher.php
+++ b/src/lint/ArcanistLintPatcher.php
@@ -1,145 +1,143 @@
 <?php
 
 /**
  * Applies lint patches to the working copy.
- *
- * @group lint
  */
 final class ArcanistLintPatcher {
 
   private $dirtyUntil     = 0;
   private $characterDelta = 0;
   private $modifiedData   = null;
   private $lineOffsets    = null;
   private $lintResult     = null;
   private $applyMessages  = array();
 
   public static function newFromArcanistLintResult(ArcanistLintResult $result) {
     $obj = new ArcanistLintPatcher();
     $obj->lintResult = $result;
     return $obj;
   }
 
   public function getUnmodifiedFileContent() {
     return $this->lintResult->getData();
   }
 
   public function getModifiedFileContent() {
     if ($this->modifiedData === null) {
       $this->buildModifiedFile();
     }
     return $this->modifiedData;
   }
 
   public function writePatchToDisk() {
     $path = $this->lintResult->getFilePathOnDisk();
     $data = $this->getModifiedFileContent();
 
     $ii = null;
     do {
       $lint = $path.'.linted'.($ii++);
     } while (file_exists($lint));
 
     // Copy existing file to preserve permissions. 'chmod --reference' is not
     // supported under OSX.
     if (Filesystem::pathExists($path)) {
       // This path may not exist if we're generating a new file.
       execx('cp -p %s %s', $path, $lint);
     }
     Filesystem::writeFile($lint, $data);
 
     list($err) = exec_manual('mv -f %s %s', $lint, $path);
     if ($err) {
       throw new Exception(
         "Unable to overwrite path `{$path}', patched version was left ".
         "at `{$lint}'.");
     }
 
     foreach ($this->applyMessages as $message) {
       $message->didApplyPatch();
     }
   }
 
   private function __construct() {
 
   }
 
   private function buildModifiedFile() {
     $data = $this->getUnmodifiedFileContent();
 
     foreach ($this->lintResult->getMessages() as $lint) {
       if (!$lint->isPatchable()) {
         continue;
       }
 
       $orig_offset  = $this->getCharacterOffset($lint->getLine() - 1);
       $orig_offset += $lint->getChar() - 1;
 
       $dirty = $this->getDirtyCharacterOffset();
       if ($dirty > $orig_offset) {
         continue;
       }
 
       // Adjust the character offset by the delta *after* checking for
       // dirtiness. The dirty character cursor is a cursor on the original file,
       // and should be compared with the patch position in the original file.
       $working_offset = $orig_offset + $this->getCharacterDelta();
 
       $old_str = $lint->getOriginalText();
       $old_len = strlen($old_str);
       $new_str = $lint->getReplacementText();
       $new_len = strlen($new_str);
 
       if ($working_offset == strlen($data)) {
         // Temporary hack to work around a destructive hphpi issue, see #451031.
         $data .= $new_str;
       } else {
         $data = substr_replace($data, $new_str, $working_offset, $old_len);
       }
 
       $this->changeCharacterDelta($new_len - $old_len);
       $this->setDirtyCharacterOffset($orig_offset + $old_len);
 
       $this->applyMessages[] = $lint;
     }
 
     $this->modifiedData = $data;
   }
 
   private function getCharacterOffset($line_num) {
     if ($this->lineOffsets === null) {
       $lines = explode("\n", $this->getUnmodifiedFileContent());
       $this->lineOffsets = array(0);
       $last = 0;
       foreach ($lines as $line) {
         $this->lineOffsets[] = $last + strlen($line) + 1;
         $last += strlen($line) + 1;
       }
     }
 
     if ($line_num >= count($this->lineOffsets)) {
       throw new Exception("Data has fewer than `{$line}' lines.");
     }
 
     return idx($this->lineOffsets, $line_num);
   }
 
   private function setDirtyCharacterOffset($offset) {
     $this->dirtyUntil = $offset;
     return $this;
   }
 
   private function getDirtyCharacterOffset() {
     return $this->dirtyUntil;
   }
 
   private function changeCharacterDelta($change) {
     $this->characterDelta += $change;
     return $this;
   }
 
   private function getCharacterDelta() {
     return $this->characterDelta;
   }
 
 }
diff --git a/src/lint/ArcanistLintResult.php b/src/lint/ArcanistLintResult.php
index 0e2dc18e..69d819ad 100644
--- a/src/lint/ArcanistLintResult.php
+++ b/src/lint/ArcanistLintResult.php
@@ -1,107 +1,104 @@
 <?php
 
 /**
  * A group of @{class:ArcanistLintMessage}s that apply to a file.
- *
- * @group lint
  */
 final class ArcanistLintResult {
 
   protected $path;
   protected $data;
   protected $filePathOnDisk;
   protected $cacheVersion;
   protected $messages = array();
   protected $effectiveMessages = array();
   private $needsSort;
 
   public function setPath($path) {
     $this->path = $path;
     return $this;
   }
 
   public function getPath() {
     return $this->path;
   }
 
   public function addMessage(ArcanistLintMessage $message) {
     $this->messages[] = $message;
     $this->needsSort = true;
     return $this;
   }
 
   public function getMessages() {
     if ($this->needsSort) {
       $this->sortAndFilterMessages();
     }
     return $this->effectiveMessages;
   }
 
   public function setData($data) {
     $this->data = $data;
     return $this;
   }
 
   public function getData() {
     return $this->data;
   }
 
   public function setFilePathOnDisk($file_path_on_disk) {
     $this->filePathOnDisk = $file_path_on_disk;
     return $this;
   }
 
   public function getFilePathOnDisk() {
     return $this->filePathOnDisk;
   }
 
   public function setCacheVersion($version) {
     $this->cacheVersion = $version;
     return $this;
   }
 
   public function getCacheVersion() {
     return $this->cacheVersion;
   }
 
   public function isPatchable() {
     foreach ($this->messages as $message) {
       if ($message->isPatchable()) {
         return true;
       }
     }
     return false;
   }
 
   public function isAllAutofix() {
     foreach ($this->messages as $message) {
       if (!$message->isAutofix()) {
         return false;
       }
     }
     return true;
   }
 
   public function sortAndFilterMessages() {
     $messages = $this->messages;
 
     foreach ($messages as $key => $message) {
       if ($message->getObsolete()) {
         unset($messages[$key]);
         continue;
       }
     }
 
     $map = array();
     foreach ($messages as $key => $message) {
       $map[$key] = ($message->getLine() * (2 << 12)) + $message->getChar();
     }
     asort($map);
     $messages = array_select_keys($messages, array_keys($map));
 
     $this->effectiveMessages = $messages;
     $this->needsSort = false;
-
   }
 
 }
diff --git a/src/lint/ArcanistLintSeverity.php b/src/lint/ArcanistLintSeverity.php
index 05ec3723..c34756d9 100644
--- a/src/lint/ArcanistLintSeverity.php
+++ b/src/lint/ArcanistLintSeverity.php
@@ -1,54 +1,50 @@
 <?php
 
 /**
  * Describes the severity of an @{class:ArcanistLintMessage}.
- *
- * @group lint
  */
 final class ArcanistLintSeverity {
 
   const SEVERITY_ADVICE       = 'advice';
   const SEVERITY_AUTOFIX      = 'autofix';
   const SEVERITY_WARNING      = 'warning';
   const SEVERITY_ERROR        = 'error';
   const SEVERITY_DISABLED     = 'disabled';
 
   public static function getLintSeverities() {
     return array(
       self::SEVERITY_ADVICE   => 'Advice',
       self::SEVERITY_AUTOFIX  => 'Auto-Fix',
       self::SEVERITY_WARNING  => 'Warning',
       self::SEVERITY_ERROR    => 'Error',
       self::SEVERITY_DISABLED => 'Disabled',
     );
   }
 
   public static function getStringForSeverity($severity_code) {
     $map = self::getLintSeverities();
 
     if (!array_key_exists($severity_code, $map)) {
       throw new Exception("Unknown lint severity '{$severity_code}'!");
     }
 
     return $map[$severity_code];
   }
 
   public static function isAtLeastAsSevere($message_sev, $level) {
-
     static $map = array(
       self::SEVERITY_DISABLED => 10,
       self::SEVERITY_ADVICE   => 20,
       self::SEVERITY_AUTOFIX  => 25,
       self::SEVERITY_WARNING  => 30,
       self::SEVERITY_ERROR    => 40,
     );
 
     if (empty($map[$message_sev])) {
       return true;
     }
 
     return $map[$message_sev] >= idx($map, $level, 0);
   }
 
-
 }
diff --git a/src/lint/engine/ArcanistLintEngine.php b/src/lint/engine/ArcanistLintEngine.php
index 2ba79fc7..6a000566 100644
--- a/src/lint/engine/ArcanistLintEngine.php
+++ b/src/lint/engine/ArcanistLintEngine.php
@@ -1,584 +1,584 @@
 <?php
 
 /**
  * Manages lint execution. When you run 'arc lint' or 'arc diff', Arcanist
  * checks your .arcconfig to see if you have specified a lint engine in the
  * key "lint.engine". The engine must extend this class. For example:
  *
  *   lang=js
  *   {
  *     // ...
  *     "lint.engine" : "ExampleLintEngine",
  *     // ...
  *   }
  *
  * The lint engine is given a list of paths (generally, the paths that you
  * modified in your change) and determines which linters to run on them. The
  * linters themselves are responsible for actually analyzing file text and
  * finding warnings and errors. For example, if the modified paths include some
  * JS files and some Python files, you might want to run JSLint on the JS files
  * and PyLint on the Python files.
  *
  * You can also run multiple linters on a single file. For instance, you might
  * run one linter on all text files to make sure they don't have trailing
  * whitespace, or enforce tab vs space rules, or make sure there are enough
  * curse words in them.
  *
  * Because lint engines are pretty custom to the rules of a project, you will
  * generally need to build your own. Fortunately, it's pretty easy (and you
  * can use the prebuilt //linters//, you just need to write a little glue code
  * to tell Arcanist which linters to run). For a simple example of how to build
  * a lint engine, see @{class:ExampleLintEngine}.
  *
  * You can test an engine like this:
  *
  *   arc lint --engine ExampleLintEngine --lintall some_file.py
  *
  * ...which will show you all the lint issues raised in the file.
  *
  * See @{article@phabricator:Arcanist User Guide: Customizing Lint, Unit Tests
  * and Workflows} for more information about configuring lint engines.
  *
- * @group lint
  * @stable
  */
 abstract class ArcanistLintEngine {
 
   protected $workingCopy;
   protected $paths = array();
   protected $fileData = array();
 
   protected $charToLine = array();
   protected $lineToFirstChar = array();
   private $cachedResults;
   private $cacheVersion;
   private $repositoryVersion;
   private $results = array();
   private $stopped = array();
   private $minimumSeverity = ArcanistLintSeverity::SEVERITY_DISABLED;
 
   private $changedLines = array();
   private $commitHookMode = false;
   private $hookAPI;
 
   private $enableAsyncLint = false;
   private $postponedLinters = array();
   private $configurationManager;
 
   private $linterResources = array();
 
   public function __construct() {
 
   }
 
   final public function setConfigurationManager(
     ArcanistConfigurationManager $configuration_manager) {
     $this->configurationManager = $configuration_manager;
     return $this;
   }
 
   final public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   final public function setWorkingCopy(
     ArcanistWorkingCopyIdentity $working_copy) {
     $this->workingCopy = $working_copy;
     return $this;
   }
 
   final public function getWorkingCopy() {
     return $this->workingCopy;
   }
 
   final public function setPaths($paths) {
     $this->paths = $paths;
     return $this;
   }
 
   public function getPaths() {
     return $this->paths;
   }
 
   final public function setPathChangedLines($path, $changed) {
     if ($changed === null) {
       $this->changedLines[$path] = null;
     } else {
       $this->changedLines[$path] = array_fill_keys($changed, true);
     }
     return $this;
   }
 
   final public function getPathChangedLines($path) {
     return idx($this->changedLines, $path);
   }
 
   final public function setFileData($data) {
     $this->fileData = $data + $this->fileData;
     return $this;
   }
 
   final public function setCommitHookMode($mode) {
     $this->commitHookMode = $mode;
     return $this;
   }
 
   final public function setHookAPI(ArcanistHookAPI $hook_api) {
     $this->hookAPI  = $hook_api;
     return $this;
   }
 
   final public function getHookAPI() {
     return $this->hookAPI;
   }
 
   final public function setEnableAsyncLint($enable_async_lint) {
     $this->enableAsyncLint = $enable_async_lint;
     return $this;
   }
 
   final public function getEnableAsyncLint() {
     return $this->enableAsyncLint;
   }
 
   final public function loadData($path) {
     if (!isset($this->fileData[$path])) {
       if ($this->getCommitHookMode()) {
         $this->fileData[$path] = $this->getHookAPI()
           ->getCurrentFileData($path);
       } else {
         $disk_path = $this->getFilePathOnDisk($path);
         $this->fileData[$path] = Filesystem::readFile($disk_path);
       }
     }
     return $this->fileData[$path];
   }
 
   public function pathExists($path) {
     if ($this->getCommitHookMode()) {
       $file_data = $this->loadData($path);
       return ($file_data !== null);
     } else {
       $disk_path = $this->getFilePathOnDisk($path);
       return Filesystem::pathExists($disk_path);
     }
   }
 
   final public function isDirectory($path) {
     if ($this->getCommitHookMode()) {
       // TODO: This won't get the right result in every case (we need more
       // metadata) but should almost always be correct.
       try {
         $this->loadData($path);
         return false;
       } catch (Exception $ex) {
         return true;
       }
     } else {
       $disk_path = $this->getFilePathOnDisk($path);
       return is_dir($disk_path);
     }
   }
 
   final public function isBinaryFile($path) {
     try {
       $data = $this->loadData($path);
     } catch (Exception $ex) {
       return false;
     }
 
     return ArcanistDiffUtils::isHeuristicBinaryFile($data);
   }
 
   final public function isSymbolicLink($path) {
     return is_link($this->getFilePathOnDisk($path));
   }
 
   final public function getFilePathOnDisk($path) {
     return Filesystem::resolvePath(
       $path,
       $this->getWorkingCopy()->getProjectRoot());
   }
 
   final public function setMinimumSeverity($severity) {
     $this->minimumSeverity = $severity;
     return $this;
   }
 
   final public function getCommitHookMode() {
     return $this->commitHookMode;
   }
 
   final public function run() {
     $linters = $this->buildLinters();
     if (!$linters) {
       throw new ArcanistNoEffectException('No linters to run.');
     }
 
     $linters = msort($linters, 'getLinterPriority');
     foreach ($linters as $linter) {
       $linter->setEngine($this);
     }
 
     $have_paths = false;
     foreach ($linters as $linter) {
       if ($linter->getPaths()) {
         $have_paths = true;
         break;
       }
     }
 
     if (!$have_paths) {
       throw new ArcanistNoEffectException('No paths are lintable.');
     }
 
     $versions = array($this->getCacheVersion());
 
     foreach ($linters as $linter) {
       $version = get_class($linter).':'.$linter->getCacheVersion();
 
       $symbols = id(new PhutilSymbolLoader())
         ->setType('class')
         ->setName(get_class($linter))
         ->selectSymbolsWithoutLoading();
       $symbol = idx($symbols, 'class$'.get_class($linter));
       if ($symbol) {
         $version .= ':'.md5_file(
           phutil_get_library_root($symbol['library']).'/'.$symbol['where']);
       }
 
       $versions[] = $version;
     }
 
     $this->cacheVersion = crc32(implode("\n", $versions));
 
     $this->stopped = array();
     $exceptions = array();
     foreach ($linters as $linter_name => $linter) {
       if (!is_string($linter_name)) {
         $linter_name = get_class($linter);
       }
       try {
         if (!$linter->canRun()) {
           continue;
         }
         $paths = $linter->getPaths();
 
         foreach ($paths as $key => $path) {
           // Make sure each path has a result generated, even if it is empty
           // (i.e., the file has no lint messages).
           $result = $this->getResultForPath($path);
           if (isset($this->stopped[$path])) {
             unset($paths[$key]);
           }
           if (isset($this->cachedResults[$path][$this->cacheVersion])) {
             $cached_result = $this->cachedResults[$path][$this->cacheVersion];
 
             $use_cache = $this->shouldUseCache(
               $linter->getCacheGranularity(),
               idx($cached_result, 'repository_version'));
 
             if ($use_cache) {
               unset($paths[$key]);
 
               if (idx($cached_result, 'stopped') == $linter_name) {
                 $this->stopped[$path] = $linter_name;
               }
             }
           }
         }
         $paths = array_values($paths);
 
         if ($paths) {
           $profiler = PhutilServiceProfiler::getInstance();
           $call_id = $profiler->beginServiceCall(array(
             'type' => 'lint',
             'linter' => $linter_name,
             'paths' => $paths,
           ));
 
           try {
             $linter->willLintPaths($paths);
             foreach ($paths as $path) {
               $linter->willLintPath($path);
               $linter->lintPath($path);
               if ($linter->didStopAllLinters()) {
                 $this->stopped[$path] = $linter_name;
               }
             }
           } catch (Exception $ex) {
             $profiler->endServiceCall($call_id, array());
             throw $ex;
           }
           $profiler->endServiceCall($call_id, array());
         }
 
       } catch (Exception $ex) {
         $exceptions[$linter_name] = $ex;
       }
     }
 
     $exceptions += $this->didRunLinters($linters);
 
     foreach ($linters as $linter) {
       foreach ($linter->getLintMessages() as $message) {
         if (!$this->isSeverityEnabled($message->getSeverity())) {
           continue;
         }
         if (!$this->isRelevantMessage($message)) {
           continue;
         }
         $message->setGranularity($linter->getCacheGranularity());
         $result = $this->getResultForPath($message->getPath());
         $result->addMessage($message);
       }
     }
 
     if ($this->cachedResults) {
       foreach ($this->cachedResults as $path => $messages) {
         $messages = idx($messages, $this->cacheVersion, array());
         $repository_version = idx($messages, 'repository_version');
         unset($messages['stopped']);
         unset($messages['repository_version']);
         foreach ($messages as $message) {
           $use_cache = $this->shouldUseCache(
             idx($message, 'granularity'),
             $repository_version);
           if ($use_cache) {
             $this->getResultForPath($path)->addMessage(
               ArcanistLintMessage::newFromDictionary($message));
           }
         }
       }
     }
 
     foreach ($this->results as $path => $result) {
       $disk_path = $this->getFilePathOnDisk($path);
       $result->setFilePathOnDisk($disk_path);
       if (isset($this->fileData[$path])) {
         $result->setData($this->fileData[$path]);
       } else if ($disk_path && Filesystem::pathExists($disk_path)) {
         // TODO: this may cause us to, e.g., load a large binary when we only
         // raised an error about its filename. We could refine this by looking
         // through the lint messages and doing this load only if any of them
         // have original/replacement text or something like that.
         try {
           $this->fileData[$path] = Filesystem::readFile($disk_path);
           $result->setData($this->fileData[$path]);
         } catch (FilesystemException $ex) {
           // Ignore this, it's noncritical that we access this data and it
           // might be unreadable or a directory or whatever else for plenty
           // of legitimate reasons.
         }
       }
     }
 
     if ($exceptions) {
       throw new PhutilAggregateException('Some linters failed:', $exceptions);
     }
 
     return $this->results;
   }
 
   final public function isSeverityEnabled($severity) {
     $minimum = $this->minimumSeverity;
     return ArcanistLintSeverity::isAtLeastAsSevere($severity, $minimum);
   }
 
-  final private function shouldUseCache($cache_granularity,
-                                        $repository_version) {
+  final private function shouldUseCache(
+    $cache_granularity,
+    $repository_version) {
+
     if ($this->commitHookMode) {
       return false;
     }
     switch ($cache_granularity) {
       case ArcanistLinter::GRANULARITY_FILE:
         return true;
       case ArcanistLinter::GRANULARITY_DIRECTORY:
       case ArcanistLinter::GRANULARITY_REPOSITORY:
         return ($this->repositoryVersion == $repository_version);
       default:
         return false;
     }
   }
 
   /**
    * @param dict<string path, dict<string version, list<dict message>>>
    * @return this
    */
   final public function setCachedResults(array $results) {
     $this->cachedResults = $results;
     return $this;
   }
 
   final public function getResults() {
     return $this->results;
   }
 
   final public function getStoppedPaths() {
     return $this->stopped;
   }
 
   abstract protected function buildLinters();
 
   final protected function didRunLinters(array $linters) {
     assert_instances_of($linters, 'ArcanistLinter');
 
     $exceptions = array();
     $profiler = PhutilServiceProfiler::getInstance();
 
     foreach ($linters as $linter_name => $linter) {
       if (!is_string($linter_name)) {
         $linter_name = get_class($linter);
       }
 
       $call_id = $profiler->beginServiceCall(array(
         'type' => 'lint',
         'linter' => $linter_name,
       ));
 
       try {
         $linter->didRunLinters();
       } catch (Exception $ex) {
         $exceptions[$linter_name] = $ex;
       }
       $profiler->endServiceCall($call_id, array());
     }
 
     return $exceptions;
   }
 
   final public function setRepositoryVersion($version) {
     $this->repositoryVersion = $version;
     return $this;
   }
 
   final private function isRelevantMessage(ArcanistLintMessage $message) {
     // When a user runs "arc lint", we default to raising only warnings on
     // lines they have changed (errors are still raised anywhere in the
     // file). The list of $changed lines may be null, to indicate that the
     // path is a directory or a binary file so we should not exclude
     // warnings.
 
     if (!$this->changedLines ||
         $message->isError() ||
         $message->shouldBypassChangedLineFiltering()) {
       return true;
     }
 
     $locations = $message->getOtherLocations();
     $locations[] = $message->toDictionary();
 
     foreach ($locations as $location) {
       $path = idx($location, 'path', $message->getPath());
 
       if (!array_key_exists($path, $this->changedLines)) {
         continue;
       }
 
       $changed = $this->getPathChangedLines($path);
 
       if ($changed === null || !$location['line']) {
         return true;
       }
 
       $last_line = $location['line'];
       if (isset($location['original'])) {
         $last_line += substr_count($location['original'], "\n");
       }
 
       for ($l = $location['line']; $l <= $last_line; $l++) {
         if (!empty($changed[$l])) {
           return true;
         }
       }
     }
 
     return false;
   }
 
   final protected function getResultForPath($path) {
     if (empty($this->results[$path])) {
       $result = new ArcanistLintResult();
       $result->setPath($path);
       $result->setCacheVersion($this->cacheVersion);
       $this->results[$path] = $result;
     }
     return $this->results[$path];
   }
 
   final public function getLineAndCharFromOffset($path, $offset) {
     if (!isset($this->charToLine[$path])) {
       $char_to_line = array();
       $line_to_first_char = array();
 
       $lines = explode("\n", $this->loadData($path));
       $line_number = 0;
       $line_start = 0;
       foreach ($lines as $line) {
         $len = strlen($line) + 1; // Account for "\n".
         $line_to_first_char[] = $line_start;
         $line_start += $len;
         for ($ii = 0; $ii < $len; $ii++) {
           $char_to_line[] = $line_number;
         }
         $line_number++;
       }
       $this->charToLine[$path] = $char_to_line;
       $this->lineToFirstChar[$path] = $line_to_first_char;
     }
 
     $line = $this->charToLine[$path][$offset];
     $char = $offset - $this->lineToFirstChar[$path][$line];
 
     return array($line, $char);
   }
 
   final public function getPostponedLinters() {
     return $this->postponedLinters;
   }
 
   final public function setPostponedLinters(array $linters) {
     $this->postponedLinters = $linters;
     return $this;
   }
 
   protected function getCacheVersion() {
     return 1;
   }
 
 
   /**
    * Get a named linter resource shared by another linter.
    *
    * This mechanism allows linters to share arbitrary resources, like the
    * results of computation. If several linters need to perform the same
    * expensive computation step, they can use a named resource to synchronize
    * construction of the result so it doesn't need to be built multiple
    * times.
    *
    * @param string  Resource identifier.
    * @param wild    Optionally, default value to return if resource does not
    *                exist.
    * @return wild   Resource, or default value if not present.
    */
   public function getLinterResource($key, $default = null) {
     return idx($this->linterResources, $key, $default);
   }
 
 
   /**
    * Set a linter resource that other linters can accesss.
    *
    * See @{method:getLinterResource} for a description of this mechanism.
    *
    * @param string Resource identifier.
    * @param wild   Resource.
    * @return this
    */
   public function setLinterResource($key, $value) {
     $this->linterResources[$key] = $value;
     return $this;
   }
 
-
 }
diff --git a/src/lint/engine/ArcanistSingleLintEngine.php b/src/lint/engine/ArcanistSingleLintEngine.php
index a001582f..34249b8c 100644
--- a/src/lint/engine/ArcanistSingleLintEngine.php
+++ b/src/lint/engine/ArcanistSingleLintEngine.php
@@ -1,63 +1,62 @@
 <?php
 
 /**
  * Run a single linter on every path unconditionally. This is a glue engine for
  * linters like @{class:ArcanistScriptAndRegexLinter}, if you are averse to
  * writing a phutil library. Your linter will receive every path, including
  * paths which have been moved or deleted.
  *
  * Set which linter should be run by configuring `lint.engine.single.linter` in
  * `.arcconfig` or user config.
- *
- * @group linter
  */
 final class ArcanistSingleLintEngine extends ArcanistLintEngine {
 
   public function buildLinters() {
     $key = 'lint.engine.single.linter';
     $linter_name = $this->getConfigurationManager()
       ->getConfigFromAnySource($key);
 
     if (!$linter_name) {
       throw new ArcanistUsageException(
         "You must configure '{$key}' with the name of a linter in order to ".
         "use ArcanistSingleLintEngine.");
     }
 
     if (!class_exists($linter_name)) {
       throw new ArcanistUsageException(
         "Linter '{$linter_name}' configured in '{$key}' does not exist!");
     }
 
     if (!is_subclass_of($linter_name, 'ArcanistLinter')) {
       throw new ArcanistUsageException(
         "Linter '{$linter_name}' configured in '{$key}' MUST be a subclass of ".
         "ArcanistLinter.");
     }
 
     // Filter the affected paths.
     $paths = $this->getPaths();
     foreach ($paths as $key => $path) {
       if (!$this->pathExists($path)) {
         // Don't lint removed files. In more complex linters it is sometimes
         // appropriate to lint removed files so you can raise a warning like
         // "you deleted X, but forgot to delete Y!", but most linters do not
         // operate correctly on removed files.
         unset($paths[$key]);
         continue;
       }
       $disk = $this->getFilePathOnDisk($path);
       if (is_dir($disk)) {
         // Don't lint directories. (In SVN, they can be directly modified by
         // changing properties on them, and may appear as modified paths.)
         unset($paths[$key]);
         continue;
       }
     }
 
     $linter = newv($linter_name, array());
     $linter->setPaths($paths);
 
     return array($linter);
   }
+
 }
diff --git a/src/lint/engine/ComprehensiveLintEngine.php b/src/lint/engine/ComprehensiveLintEngine.php
index ed8f6aec..a7f12e09 100644
--- a/src/lint/engine/ComprehensiveLintEngine.php
+++ b/src/lint/engine/ComprehensiveLintEngine.php
@@ -1,57 +1,55 @@
 <?php
 
 /**
- * Basic lint engine which just applies several linters based on the file types
- *
- * @group linter
+ * Basic lint engine which just applies several linters based on the file types.
  */
 final class ComprehensiveLintEngine extends ArcanistLintEngine {
 
   public function buildLinters() {
     $linters = array();
 
     $paths = $this->getPaths();
 
     foreach ($paths as $key => $path) {
       if (preg_match('@^externals/@', $path)) {
         // Third-party stuff lives in /externals/; don't run lint engines
         // against it.
         unset($paths[$key]);
       }
     }
 
     $text_paths = preg_grep('/\.(php|css|hpp|cpp|l|y|py|pl)$/', $paths);
     $linters[] = id(new ArcanistGeneratedLinter())->setPaths($text_paths);
     $linters[] = id(new ArcanistNoLintLinter())->setPaths($text_paths);
     $linters[] = id(new ArcanistTextLinter())->setPaths($text_paths);
 
     $linters[] = id(new ArcanistFilenameLinter())->setPaths($paths);
 
     $linters[] = id(new ArcanistXHPASTLinter())
       ->setPaths(preg_grep('/\.php$/', $paths));
 
     $py_paths = preg_grep('/\.py$/', $paths);
     $linters[] = id(new ArcanistPyFlakesLinter())->setPaths($py_paths);
     $linters[] = id(new ArcanistPEP8Linter())
       ->setFlags($this->getPEP8WithTextOptions())
       ->setPaths($py_paths);
 
     $linters[] = id(new ArcanistRubyLinter())
       ->setPaths(preg_grep('/\.rb$/', $paths));
 
     $linters[] = id(new ArcanistJSHintLinter())
       ->setPaths(preg_grep('/\.js$/', $paths));
 
     return $linters;
   }
 
   protected function getPEP8WithTextOptions() {
     // E101 is subset of TXT2 (Tab Literal).
     // E501 is same as TXT3 (Line Too Long).
     // W291 is same as TXT6 (Trailing Whitespace).
     // W292 is same as TXT4 (File Does Not End in Newline).
     // W293 is same as TXT6 (Trailing Whitespace).
     return array('--ignore=E101,E501,W291,W292,W293');
   }
 
 }
diff --git a/src/lint/engine/UnitTestableArcanistLintEngine.php b/src/lint/engine/UnitTestableArcanistLintEngine.php
index 5fd90cb0..4c1f771a 100644
--- a/src/lint/engine/UnitTestableArcanistLintEngine.php
+++ b/src/lint/engine/UnitTestableArcanistLintEngine.php
@@ -1,34 +1,32 @@
 <?php
 
 /**
  * Lint engine for use in constructing test cases. See
  * @{class:ArcanistLinterTestCase}.
- *
- * @group testcase
  */
 final class UnitTestableArcanistLintEngine extends ArcanistLintEngine {
 
   protected $linters = array();
 
   public function addLinter($linter) {
     $this->linters[] = $linter;
     return $this;
   }
 
   public function addFileData($path, $data) {
     $this->fileData[$path] = $data;
     return $this;
   }
 
   public function pathExists($path) {
     if (idx($this->fileData, $path)) {
       return true;
     }
     return parent::pathExists($path);
   }
 
   protected function buildLinters() {
     return $this->linters;
   }
 
 }
diff --git a/src/lint/linter/ArcanistCSharpLinter.php b/src/lint/linter/ArcanistCSharpLinter.php
index a9b9a257..6f0206cd 100644
--- a/src/lint/linter/ArcanistCSharpLinter.php
+++ b/src/lint/linter/ArcanistCSharpLinter.php
@@ -1,246 +1,246 @@
 <?php
 
 /**
  * C# linter for Arcanist.
  */
 final class ArcanistCSharpLinter extends ArcanistLinter {
 
   private $runtimeEngine;
   private $cslintEngine;
   private $cslintHintPath;
   private $loaded;
   private $discoveryMap;
   private $futures;
 
   const SUPPORTED_VERSION = 1;
 
   public function getLinterName() {
     return 'C#';
   }
 
   public function getLinterConfigurationName() {
     return 'csharp';
   }
 
   public function getLinterConfigurationOptions() {
     $options = parent::getLinterConfigurationOptions();
 
     $options['discovery'] = array(
       'type' => 'map<string, list<string>>',
       'help' => pht('Provide a discovery map.'),
     );
 
 
     // TODO: This should probably be replaced with "bin" when this moves
     // to extend ExternalLinter.
 
     $options['binary'] = array(
       'type' => 'string',
       'help' => pht('Override default binary.'),
     );
 
     return $options;
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'discovery':
         $this->discoveryMap = $value;
         return;
       case 'binary':
         $this->cslintHintPath = $value;
         return;
     }
     parent::setLinterConfigurationValue($key, $value);
   }
 
   public function getLintCodeFromLinterConfigurationKey($code) {
     return $code;
   }
 
   public function setCustomSeverityMap(array $map) {
     foreach ($map as $code => $severity) {
       if (substr($code, 0, 2) === 'SA' && $severity == 'disabled') {
         throw new Exception(
           "In order to keep StyleCop integration with IDEs and other tools ".
           "consistent with Arcanist results, you aren't permitted to ".
-          "disable StyleCop rules within '.arclint'.  ".
+          "disable StyleCop rules within '.arclint'. ".
           "Instead configure the severity using the StyleCop settings dialog ".
-          "(usually accessible from within your IDE).  StyleCop settings ".
+          "(usually accessible from within your IDE). StyleCop settings ".
           "for your project will be used when linting for Arcanist.");
       }
     }
     return parent::setCustomSeverityMap($map);
   }
 
   /**
-   * Determines what executables and lint paths to use.  Between platforms
-   * this also changes whether the lint engine is run under .NET or Mono.  It
+   * Determines what executables and lint paths to use. Between platforms
+   * this also changes whether the lint engine is run under .NET or Mono. It
    * also ensures that all of the required binaries are available for the lint
    * to run successfully.
    *
    * @return void
    */
   private function loadEnvironment() {
     if ($this->loaded) {
       return;
     }
 
     // Determine runtime engine (.NET or Mono).
     if (phutil_is_windows()) {
       $this->runtimeEngine = '';
     } else if (Filesystem::binaryExists('mono')) {
       $this->runtimeEngine = 'mono ';
     } else {
       throw new Exception('Unable to find Mono and you are not on Windows!');
     }
 
     // Determine cslint path.
     $cslint = $this->cslintHintPath;
     if ($cslint !== null && file_exists($cslint)) {
       $this->cslintEngine = Filesystem::resolvePath($cslint);
     } else if (Filesystem::binaryExists('cslint.exe')) {
       $this->cslintEngine = 'cslint.exe';
     } else {
       throw new Exception('Unable to locate cslint.');
     }
 
     // Determine cslint version.
     $ver_future = new ExecFuture(
       '%C -v',
       $this->runtimeEngine.$this->cslintEngine);
     list($err, $stdout, $stderr) = $ver_future->resolve();
     if ($err !== 0) {
       throw new Exception(
-        'You are running an old version of cslint.  Please '.
+        'You are running an old version of cslint. Please '.
         'upgrade to version '.self::SUPPORTED_VERSION.'.');
     }
     $ver = (int)$stdout;
     if ($ver < self::SUPPORTED_VERSION) {
       throw new Exception(
-        'You are running an old version of cslint.  Please '.
+        'You are running an old version of cslint. Please '.
         'upgrade to version '.self::SUPPORTED_VERSION.'.');
     } else if ($ver > self::SUPPORTED_VERSION) {
       throw new Exception(
         'Arcanist does not support this version of cslint (it is '.
-        'newer).  You can try upgrading Arcanist with `arc upgrade`.');
+        'newer). You can try upgrading Arcanist with `arc upgrade`.');
     }
 
     $this->loaded = true;
   }
 
   public function lintPath($path) {}
 
   public function willLintPaths(array $paths) {
     $this->loadEnvironment();
 
     $futures = array();
 
     // Bulk linting up into futures, where the number of files
     // is based on how long the command is.
     $current_paths = array();
     foreach ($paths as $path) {
       // If the current paths for the command, plus the next path
       // is greater than 6000 characters (less than the Windows
       // command line limit), then finalize this future and add it.
       $total = 0;
       foreach ($current_paths as $current_path) {
         $total += strlen($current_path) + 3; // Quotes and space.
       }
       if ($total + strlen($path) > 6000) {
         // %s won't pass through the JSON correctly
-        // under Windows.  This is probably because not only
+        // under Windows. This is probably because not only
         // does the JSON have quotation marks in the content,
         // but because there'll be a lot of escaping and
         // double escaping because the JSON also contains
-        // regular expressions.  cslint supports passing the
+        // regular expressions. cslint supports passing the
         // settings JSON through base64-encoded to mitigate
         // this issue.
         $futures[] = new ExecFuture(
           '%C --settings-base64=%s -r=. %Ls',
           $this->runtimeEngine.$this->cslintEngine,
           base64_encode(json_encode($this->discoveryMap)),
           $current_paths);
         $current_paths = array();
       }
 
       // Append the path to the current paths array.
       $current_paths[] = $this->getEngine()->getFilePathOnDisk($path);
     }
 
     // If we still have paths left in current paths, then we need to create
     // a future for those too.
     if (count($current_paths) > 0) {
       $futures[] = new ExecFuture(
         '%C --settings-base64=%s -r=. %Ls',
         $this->runtimeEngine.$this->cslintEngine,
         base64_encode(json_encode($this->discoveryMap)),
         $current_paths);
       $current_paths = array();
     }
 
     $this->futures = $futures;
   }
 
   public function didRunLinters() {
     if ($this->futures) {
       foreach (Futures($this->futures)->limit(8) as $future) {
         $this->resolveFuture($future);
       }
     }
   }
 
   protected function resolveFuture(Future $future) {
     list($stdout) = $future->resolvex();
     $all_results = json_decode($stdout);
     foreach ($all_results as $results) {
       if ($results === null || $results->Issues === null) {
         return;
       }
       foreach ($results->Issues as $issue) {
         $message = new ArcanistLintMessage();
         $message->setPath($results->FileName);
         $message->setLine($issue->LineNumber);
         $message->setCode($issue->Index->Code);
         $message->setName($issue->Index->Name);
         $message->setChar($issue->Column);
         $message->setOriginalText($issue->OriginalText);
         $message->setReplacementText($issue->ReplacementText);
         $desc = @vsprintf($issue->Index->Message, $issue->Parameters);
         if ($desc === false) {
           $desc = $issue->Index->Message;
         }
         $message->setDescription($desc);
         $severity = ArcanistLintSeverity::SEVERITY_ADVICE;
         switch ($issue->Index->Severity) {
           case 0:
             $severity = ArcanistLintSeverity::SEVERITY_ADVICE;
             break;
           case 1:
             $severity = ArcanistLintSeverity::SEVERITY_AUTOFIX;
             break;
           case 2:
             $severity = ArcanistLintSeverity::SEVERITY_WARNING;
             break;
           case 3:
             $severity = ArcanistLintSeverity::SEVERITY_ERROR;
             break;
           case 4:
             $severity = ArcanistLintSeverity::SEVERITY_DISABLED;
             break;
         }
         $severity_override = $this->getLintMessageSeverity($issue->Index->Code);
         if ($severity_override !== null) {
           $severity = $severity_override;
         }
         $message->setSeverity($severity);
         $this->addLintMessage($message);
       }
     }
   }
 
   protected function getDefaultMessageSeverity($code) {
     return null;
   }
 
 }
diff --git a/src/lint/linter/ArcanistConduitLinter.php b/src/lint/linter/ArcanistConduitLinter.php
index 5a7a67a2..44edc2d7 100644
--- a/src/lint/linter/ArcanistConduitLinter.php
+++ b/src/lint/linter/ArcanistConduitLinter.php
@@ -1,102 +1,101 @@
 <?php
 
 /**
  * Implements linting via Conduit RPC call.
  * Slow by definition, but allows sophisticated linting that relies on
  * stuff like big indexes of a codebase.
  * Recommended usage is to gate these to the advice lint level.
  *
  * The conduit endpoint should implement a method named the same as
  * the value of ArcanistConduitLinter::CONDUIT_METHOD.
  *
  * It takes an array with a key 'file_contents' which is an array mapping
  * file paths to their complete contents.
  *
  * It should return an array mapping those same paths to arrays describing the
  * lint for each path.
  *
  * The lint for a path is described as a list of structured dictionaries.
  *
  * The dictionary structure is effectively defined by
  * ArcanistLintMessage::newFromDictionary.
  *
  * Effective keys are:
  *  'path' => must match passed in path.
  *  'line'
  *  'char'
  *  'code'
  *  'severity' => Must match a constant in ArcanistLintSeverity.
  *  'name'
  *  'description'
  *  'original' & 'replacement' => optional patch information
  *  'locations' => other locations of the same error (in the same format)
  *
  * This class is intended for customization via instantiation, not via
  * subclassing.
  */
 final class ArcanistConduitLinter extends ArcanistLinter {
   const CONDUIT_METHOD = 'lint.getalllint';
 
   private $conduitURI;
   private $linterName;
   private $lintByPath; // array(/pa/th/ => <lint>), valid after willLintPaths().
 
   public function __construct($conduit_uri = null, $linter_name = null) {
 
     // TODO: Facebook uses this (probably?) but we need to be able to
     // construct it without arguments for ".arclint".
 
     $this->conduitURI = $conduit_uri;
     $this->linterName = $linter_name;
   }
 
   public function willLintPaths(array $paths) {
     // Load all file path data into $this->data.
     array_map(array($this, 'getData'), $paths);
 
     $conduit = new ConduitClient($this->conduitURI);
 
     $this->lintByPath = $conduit->callMethodSynchronous(
       self::CONDUIT_METHOD,
       array(
         'file_contents' => $this->data,
       ));
   }
 
   public function lintPath($path) {
     $lint_for_path = idx($this->lintByPath, $path);
     if (!$lint_for_path) {
       return;
     }
 
     foreach ($lint_for_path as $lint) {
       $this->addLintMessage(ArcanistLintMessage::newFromDictionary($lint));
     }
   }
 
   public function getLinterName() {
     return $this->linterName;
   }
 
   public function getLintSeverityMap() {
     // The rationale here is that this class will only be used for custom
     // linting in installations. No two server endpoints will be the same across
     // different instantiations. Therefore, the server can handle all severity
     // customization directly.
     throw new ArcanistUsageException(
       'ArcanistConduitLinter does not support client-side severity '.
-      'customization.'
-    );
+      'customization.');
   }
 
   public function getLintNameMap() {
     // See getLintSeverityMap for rationale.
     throw new ArcanistUsageException(
-      'ArcanistConduitLinter does not support a name map.'
-    );
+      'ArcanistConduitLinter does not support a name map.');
   }
 
   protected function canCustomizeLintSeverities() {
     return false;
   }
+
 }
diff --git a/src/lint/linter/ArcanistJSONLintLinter.php b/src/lint/linter/ArcanistJSONLintLinter.php
index 1cd4e9bd..254f8b31 100644
--- a/src/lint/linter/ArcanistJSONLintLinter.php
+++ b/src/lint/linter/ArcanistJSONLintLinter.php
@@ -1,96 +1,97 @@
 <?php
 
 /**
  * A linter for JSON files.
  */
 final class ArcanistJSONLintLinter extends ArcanistExternalLinter {
 
   public function getInfoName() {
     return 'JSON Lint';
   }
 
   public function getInfoURI() {
     return 'https://github.com/zaach/jsonlint';
   }
 
   public function getInfoDescription() {
     return pht('Use `jsonlint` to detect syntax errors in JSON files.');
   }
 
   public function getLinterName() {
     return 'JSON';
   }
 
   public function getLinterConfigurationName() {
     return 'jsonlint';
   }
 
   public function getDefaultBinary() {
     return 'jsonlint';
   }
 
   public function getVersion() {
     // NOTE: `jsonlint --version` returns a non-zero exit status.
     list($err, $stdout) = exec_manual(
       '%C --version',
       $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+\.\d+)$/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install jsonlint using `npm install -g jsonlint`.');
   }
 
   public function shouldExpectCommandErrors() {
     return true;
   }
 
   public function supportsReadDataFromStdin() {
     return true;
   }
 
   protected function getMandatoryFlags() {
     return array(
       '--compact',
     );
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stderr, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       $match = preg_match(
         '/^(?:(?<path>.+): )?'.
         'line (?<line>\d+), col (?<column>\d+), '.
         '(?<description>.*)$/',
         $line,
         $matches);
 
       if ($match) {
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($matches['line']);
         $message->setChar($matches['column']);
         $message->setCode($this->getLinterName());
         $message->setDescription(ucfirst($matches['description']));
         $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
 
         $messages[] = $message;
       }
     }
 
     if ($err && !$messages) {
       return false;
     }
 
     return $messages;
   }
+
 }
diff --git a/src/lint/linter/ArcanistLinter.php b/src/lint/linter/ArcanistLinter.php
index 9001362d..2987b7c2 100644
--- a/src/lint/linter/ArcanistLinter.php
+++ b/src/lint/linter/ArcanistLinter.php
@@ -1,503 +1,502 @@
 <?php
 
 /**
  * Implements lint rules, like syntax checks for a specific language.
  *
  * @task info Human Readable Information
- *
  * @stable
  */
 abstract class ArcanistLinter {
 
   const GRANULARITY_FILE = 1;
   const GRANULARITY_DIRECTORY = 2;
   const GRANULARITY_REPOSITORY = 3;
   const GRANULARITY_GLOBAL = 4;
 
   protected $paths  = array();
   protected $data   = array();
   protected $engine;
   protected $activePath;
   protected $messages = array();
 
   protected $stopAllLinters = false;
 
   private $customSeverityMap = array();
   private $customSeverityRules = array();
 
 
 /*  -(  Human Readable Information  )---------------------------------------- */
 
   /**
    * Return an optional informative URI where humans can learn more about this
    * linter.
    *
    * For most linters, this should return a link to the project home page. This
    * is shown on `arc linters`.
    *
    * @return string|null Optionally, return an informative URI.
    * @task info
    */
   public function getInfoURI() {
     return null;
   }
 
   /**
    * Return a brief human-readable description of the linter.
    *
    * These should be a line or two, and are shown on `arc linters`.
    *
    * @return string|null Optionally, return a brief human-readable description.
    * @task info
    */
   public function getInfoDescription() {
     return null;
   }
 
   /**
    * Return a human-readable linter name.
    *
    * These are used by `arc linters`, and can let you give a linter a more
    * presentable name.
    *
    * @return string Human-readable linter name.
    * @task info
    */
   public function getInfoName() {
     return nonempty(
       $this->getLinterName(),
       $this->getLinterConfigurationName(),
       get_class($this));
   }
 
   public function getLinterPriority() {
     return 1.0;
   }
 
   public function setCustomSeverityMap(array $map) {
     $this->customSeverityMap = $map;
     return $this;
   }
 
   public function setCustomSeverityRules(array $rules) {
     $this->customSeverityRules = $rules;
     return $this;
   }
 
   final public function getActivePath() {
     return $this->activePath;
   }
 
   final public function getOtherLocation($offset, $path = null) {
     if ($path === null) {
       $path = $this->getActivePath();
     }
 
     list($line, $char) = $this->getEngine()->getLineAndCharFromOffset(
       $path,
       $offset);
 
     return array(
       'path' => $path,
       'line' => $line + 1,
       'char' => $char,
     );
   }
 
   final public function stopAllLinters() {
     $this->stopAllLinters = true;
     return $this;
   }
 
   final public function didStopAllLinters() {
     return $this->stopAllLinters;
   }
 
   final public function addPath($path) {
     $this->paths[$path] = $path;
     return $this;
   }
 
   final public function setPaths(array $paths) {
     $this->paths = $paths;
     return $this;
   }
 
   /**
    * Filter out paths which this linter doesn't act on (for example, because
    * they are binaries and the linter doesn't apply to binaries).
    */
   final private function filterPaths($paths) {
     $engine = $this->getEngine();
 
     $keep = array();
     foreach ($paths as $path) {
       if (!$this->shouldLintDeletedFiles() && !$engine->pathExists($path)) {
         continue;
       }
 
       if (!$this->shouldLintDirectories() && $engine->isDirectory($path)) {
         continue;
       }
 
       if (!$this->shouldLintBinaryFiles() && $engine->isBinaryFile($path)) {
         continue;
       }
 
       if (!$this->shouldLintSymbolicLinks() && $engine->isSymbolicLink($path)) {
         continue;
       }
 
       $keep[] = $path;
     }
 
     return $keep;
   }
 
   final public function getPaths() {
     return $this->filterPaths(array_values($this->paths));
   }
 
   final public function addData($path, $data) {
     $this->data[$path] = $data;
     return $this;
   }
 
   final protected function getData($path) {
     if (!array_key_exists($path, $this->data)) {
       $this->data[$path] = $this->getEngine()->loadData($path);
     }
     return $this->data[$path];
   }
 
   final public function setEngine(ArcanistLintEngine $engine) {
     $this->engine = $engine;
     return $this;
   }
 
   final protected function getEngine() {
     return $this->engine;
   }
 
   public function getCacheVersion() {
     return 0;
   }
 
   final public function getLintMessageFullCode($short_code) {
     return $this->getLinterName().$short_code;
   }
 
   final public function getLintMessageSeverity($code) {
     $map = $this->customSeverityMap;
     if (isset($map[$code])) {
       return $map[$code];
     }
 
     $map = $this->getLintSeverityMap();
     if (isset($map[$code])) {
       return $map[$code];
     }
 
     foreach ($this->customSeverityRules as $rule => $severity) {
       if (preg_match($rule, $code)) {
         return $severity;
       }
     }
 
     return $this->getDefaultMessageSeverity($code);
   }
 
   protected function getDefaultMessageSeverity($code) {
     return ArcanistLintSeverity::SEVERITY_ERROR;
   }
 
   final public function isMessageEnabled($code) {
     return ($this->getLintMessageSeverity($code) !==
             ArcanistLintSeverity::SEVERITY_DISABLED);
   }
 
   final public function getLintMessageName($code) {
     $map = $this->getLintNameMap();
     if (isset($map[$code])) {
       return $map[$code];
     }
     return 'Unknown lint message!';
   }
 
   final protected function addLintMessage(ArcanistLintMessage $message) {
     if (!$this->getEngine()->getCommitHookMode()) {
       $root = $this->getEngine()->getWorkingCopy()->getProjectRoot();
       $path = Filesystem::resolvePath($message->getPath(), $root);
       $message->setPath(Filesystem::readablePath($path, $root));
     }
     $this->messages[] = $message;
     return $message;
   }
 
   final public function getLintMessages() {
     return $this->messages;
   }
 
   final protected function raiseLintAtLine(
     $line,
     $char,
     $code,
     $desc,
     $original = null,
     $replacement = null) {
 
     $message = id(new ArcanistLintMessage())
       ->setPath($this->getActivePath())
       ->setLine($line)
       ->setChar($char)
       ->setCode($this->getLintMessageFullCode($code))
       ->setSeverity($this->getLintMessageSeverity($code))
       ->setName($this->getLintMessageName($code))
       ->setDescription($desc)
       ->setOriginalText($original)
       ->setReplacementText($replacement);
 
     return $this->addLintMessage($message);
   }
 
   final protected function raiseLintAtPath($code, $desc) {
     return $this->raiseLintAtLine(null, null, $code, $desc, null, null);
   }
 
   final protected function raiseLintAtOffset(
     $offset,
     $code,
     $desc,
     $original = null,
     $replacement = null) {
 
     $path = $this->getActivePath();
     $engine = $this->getEngine();
     if ($offset === null) {
       $line = null;
       $char = null;
     } else {
       list($line, $char) = $engine->getLineAndCharFromOffset($path, $offset);
     }
 
     return $this->raiseLintAtLine(
       $line + 1,
       $char + 1,
       $code,
       $desc,
       $original,
       $replacement);
   }
 
   public function willLintPath($path) {
     $this->stopAllLinters = false;
     $this->activePath = $path;
   }
 
   public function canRun() {
     return true;
   }
 
   public function willLintPaths(array $paths) {
     return;
   }
 
   abstract public function lintPath($path);
   abstract public function getLinterName();
 
   public function getVersion() {
     return null;
   }
 
   public function didRunLinters() {
     // This is a hook.
   }
 
   final protected function isCodeEnabled($code) {
     $severity = $this->getLintMessageSeverity($code);
     return $this->getEngine()->isSeverityEnabled($severity);
   }
 
   public function getLintSeverityMap() {
     return array();
   }
 
   public function getLintNameMap() {
     return array();
   }
 
   public function getCacheGranularity() {
     return self::GRANULARITY_FILE;
   }
 
   /**
    * If this linter is selectable via `.arclint` configuration files, return
    * a short, human-readable name to identify it. For example, `"jshint"` or
    * `"pep8"`.
    *
    * If you do not implement this method, the linter will not be selectable
    * through `.arclint` files.
    */
   public function getLinterConfigurationName() {
     return null;
   }
 
   public function getLinterConfigurationOptions() {
     if (!$this->canCustomizeLintSeverities()) {
       return array();
     }
 
     return array(
       'severity' => array(
         'type' => 'optional map<string|int, string>',
         'help' => pht(
           'Provide a map from lint codes to adjusted severity levels: error, '.
           'warning, advice, autofix or disabled.')
       ),
       'severity.rules' => array(
         'type' => 'optional map<string, string>',
         'help' => pht(
           'Provide a map of regular expressions to severity levels. All '.
           'matching codes have their severity adjusted.'),
       ),
     );
   }
 
   public function setLinterConfigurationValue($key, $value) {
     $sev_map = array(
       'error' => ArcanistLintSeverity::SEVERITY_ERROR,
       'warning' => ArcanistLintSeverity::SEVERITY_WARNING,
       'autofix' => ArcanistLintSeverity::SEVERITY_AUTOFIX,
       'advice' => ArcanistLintSeverity::SEVERITY_ADVICE,
       'disabled' => ArcanistLintSeverity::SEVERITY_DISABLED,
     );
 
     switch ($key) {
       case 'severity':
         if (!$this->canCustomizeLintSeverities()) {
           break;
         }
 
         $custom = array();
         foreach ($value as $code => $severity) {
           if (empty($sev_map[$severity])) {
             $valid = implode(', ', array_keys($sev_map));
             throw new Exception(
               pht(
                 'Unknown lint severity "%s". Valid severities are: %s.',
                 $severity,
                 $valid));
           }
           $code = $this->getLintCodeFromLinterConfigurationKey($code);
           $custom[$code] = $severity;
         }
 
         $this->setCustomSeverityMap($custom);
         return;
 
       case 'severity.rules':
         if (!$this->canCustomizeLintSeverities()) {
           break;
         }
 
         foreach ($value as $rule => $severity) {
           if (@preg_match($rule, '') === false) {
             throw new Exception(
               pht(
                 'Severity rule "%s" is not a valid regular expression.',
                 $rule));
           }
           if (empty($sev_map[$severity])) {
             $valid = implode(', ', array_keys($sev_map));
             throw new Exception(
               pht(
                 'Unknown lint severity "%s". Valid severities are: %s.',
                 $severity,
                 $valid));
           }
         }
         $this->setCustomSeverityRules($value);
         return;
     }
 
     throw new Exception("Incomplete implementation: {$key}!");
   }
 
   protected function canCustomizeLintSeverities() {
     return true;
   }
 
   protected function shouldLintBinaryFiles() {
     return false;
   }
 
   protected function shouldLintDeletedFiles() {
     return false;
   }
 
   protected function shouldLintDirectories() {
     return false;
   }
 
   protected function shouldLintSymbolicLinks() {
     return false;
   }
 
   /**
    * Map a configuration lint code to an `arc` lint code. Primarily, this is
    * intended for validation, but can also be used to normalize case or
    * otherwise be more permissive in accepted inputs.
    *
    * If the code is not recognized, you should throw an exception.
    *
    * @param string  Code specified in configuration.
    * @return string  Normalized code to use in severity map.
    */
   protected function getLintCodeFromLinterConfigurationKey($code) {
     return $code;
   }
 
   /**
    * Retrieve an old lint configuration value from `.arcconfig` or a similar
    * source.
    *
    * Modern linters should use @{method:getConfig} to read configuration from
    * `.arclint`.
    *
    * @param   string  Configuration key to retrieve.
    * @param   wild    Default value to return if key is not present in config.
    * @return  wild    Configured value, or default if no configuration exists.
    */
   final protected function getDeprecatedConfiguration($key, $default = null) {
     // If we're being called in a context without an engine (probably from
     // `arc linters`), just return the default value.
     if (!$this->engine) {
       return $default;
     }
 
     $config = $this->getEngine()->getConfigurationManager();
 
     // Construct a sentinel object so we can tell if we're reading config
     // or not.
     $sentinel = (object)array();
     $result = $config->getConfigFromAnySource($key, $sentinel);
 
     // If we read config, warn the user that this mechanism is deprecated and
     // discouraged.
     if ($result !== $sentinel) {
       $console = PhutilConsole::getConsole();
       $console->writeErr(
         "**%s**: %s\n",
         pht('Deprecation Warning'),
         pht(
           'Configuration option "%s" is deprecated. Generally, linters should '.
           'now be configured using an `.arclint` file. See "Arcanist User '.
           'Guide: Lint" in the documentation for more information.',
           $key));
       return $result;
     }
 
     return $default;
   }
 
 }
diff --git a/src/lint/linter/ArcanistMergeConflictLinter.php b/src/lint/linter/ArcanistMergeConflictLinter.php
index 021b456f..b4db9f9a 100644
--- a/src/lint/linter/ArcanistMergeConflictLinter.php
+++ b/src/lint/linter/ArcanistMergeConflictLinter.php
@@ -1,53 +1,54 @@
 <?php
 
 /**
  * Checks files for unresolved merge conflicts.
  */
 final class ArcanistMergeConflictLinter extends ArcanistLinter {
 
   const LINT_MERGECONFLICT = 1;
 
   public function getInfoName() {
     return pht('Merge Conflicts');
   }
 
   public function getInfoDescription() {
     return pht(
       'Raises errors on unresolved merge conflicts in source files, to catch '.
       'mistakes where a conflicted file is accidentally marked as resolved.');
   }
 
   public function getLinterName() {
     return 'MERGECONFLICT';
   }
 
   public function getLinterConfigurationName() {
     return 'merge-conflict';
   }
 
   public function willLintPaths(array $paths) {
     return;
   }
 
   public function lintPath($path) {
     $lines = phutil_split_lines($this->getData($path), false);
 
     foreach ($lines as $lineno => $line) {
       // An unresolved merge conflict will contain a series of seven
       // '<', '=', or '>'.
       if (preg_match('/^(>{7}|<{7}|={7})$/', $line)) {
         $this->raiseLintAtLine(
           $lineno + 1,
           1,
           self::LINT_MERGECONFLICT,
           pht('This syntax indicates there is an unresolved merge conflict.'));
       }
     }
   }
 
   public function getLintNameMap() {
     return array(
       self::LINT_MERGECONFLICT => pht('Unresolved merge conflict'),
     );
   }
+
 }
diff --git a/src/lint/linter/ArcanistPhpcsLinter.php b/src/lint/linter/ArcanistPhpcsLinter.php
index dccbc01b..870d1860 100644
--- a/src/lint/linter/ArcanistPhpcsLinter.php
+++ b/src/lint/linter/ArcanistPhpcsLinter.php
@@ -1,142 +1,140 @@
 <?php
 
 /**
  * Uses "PHP_CodeSniffer" to detect checkstyle errors in PHP code.
- *
- * @group linter
  */
 final class ArcanistPhpcsLinter extends ArcanistExternalLinter {
 
   private $reports;
 
   public function getInfoName() {
     return 'PHP_CodeSniffer';
   }
 
   public function getInfoURI() {
     return 'http://pear.php.net/package/PHP_CodeSniffer/';
   }
 
   public function getInfoDescription() {
     return pht(
       'PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files and '.
       'detects violations of a defined set of coding standards.');
   }
 
   public function getLinterName() {
     return 'PHPCS';
   }
 
   public function getLinterConfigurationName() {
     return 'phpcs';
   }
 
   public function getMandatoryFlags() {
     return array('--report=xml');
   }
 
   public function getInstallInstructions() {
     return pht('Install PHPCS with `pear install PHP_CodeSniffer`.');
   }
 
   public function getDefaultFlags() {
     $options = $this->getDeprecatedConfiguration('lint.phpcs.options', array());
     $standard = $this->getDeprecatedConfiguration('lint.phpcs.standard');
 
     if (!empty($standard)) {
       if (is_array($options)) {
         $options[] = '--standard='.$standard;
       } else {
         $options .= ' --standard='.$standard;
       }
     }
 
     return $options;
   }
 
   public function getDefaultBinary() {
     return $this->getDeprecatedConfiguration('lint.phpcs.bin', 'phpcs');
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^PHP_CodeSniffer version (?P<version>\d+\.\d+\.\d+)\b/';
     if (preg_match($regex, $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function shouldExpectCommandErrors() {
     return true;
   }
 
   public function supportsReadDataFromStdin() {
     return true;
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     // NOTE: Some version of PHPCS after 1.4.6 stopped printing a valid, empty
     // XML document to stdout in the case of no errors. If PHPCS exits with
     // error 0, just ignore output.
     if (!$err) {
       return array();
     }
 
     $report_dom = new DOMDocument();
     $ok = @$report_dom->loadXML($stdout);
     if (!$ok) {
       return false;
     }
 
     $files = $report_dom->getElementsByTagName('file');
     $messages = array();
     foreach ($files as $file) {
       foreach ($file->childNodes as $child) {
         if (!($child instanceof DOMElement)) {
           continue;
         }
 
         if ($child->tagName == 'error') {
           $prefix = 'E';
         } else {
           $prefix = 'W';
         }
 
         $code = 'PHPCS.'.$prefix.'.'.$child->getAttribute('source');
 
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($child->getAttribute('line'));
         $message->setChar($child->getAttribute('column'));
         $message->setCode($code);
         $message->setDescription($child->nodeValue);
         $message->setSeverity($this->getLintMessageSeverity($code));
 
         $messages[] = $message;
       }
     }
 
     return $messages;
   }
 
   protected function getDefaultMessageSeverity($code) {
     if (preg_match('/^PHPCS\\.W\\./', $code)) {
       return ArcanistLintSeverity::SEVERITY_WARNING;
     } else {
       return ArcanistLintSeverity::SEVERITY_ERROR;
     }
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     if (!preg_match('/^PHPCS\\.(E|W)\\./', $code)) {
       throw new Exception(
         "Invalid severity code '{$code}', should begin with 'PHPCS.'.");
     }
     return $code;
   }
 
 }
diff --git a/src/lint/linter/ArcanistPuppetLintLinter.php b/src/lint/linter/ArcanistPuppetLintLinter.php
index 74f6458b..5fc20705 100644
--- a/src/lint/linter/ArcanistPuppetLintLinter.php
+++ b/src/lint/linter/ArcanistPuppetLintLinter.php
@@ -1,106 +1,107 @@
 <?php
 
 /**
  * A linter for Puppet files.
  */
 final class ArcanistPuppetLintLinter extends ArcanistExternalLinter {
 
   public function getInfoURI() {
     return 'http://puppet-lint.com/';
   }
 
   public function getInfoName() {
     return pht('puppet-lint');
   }
 
   public function getInfoDescription() {
     return pht(
       'Use `puppet-lint` to check that your Puppet manifests conform to '.
       'the style guide.');
   }
 
   public function getLinterName() {
     return 'PUPPETLINT';
   }
 
   public function getLinterConfigurationName() {
     return 'puppet-lint';
   }
 
   public function getDefaultBinary() {
     return 'puppet-lint';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^Puppet-lint (?P<version>\d+\.\d+\.\d+)$/';
     if (preg_match($regex, $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install puppet-lint using `gem install puppet-lint`.');
   }
 
   public function shouldExpectCommandErrors() {
     return true;
   }
 
   public function supportsReadDataFromStdin() {
     return false;
   }
 
   protected function getMandatoryFlags() {
     return array(sprintf('--log-format=%s', implode('|', array(
       '%{linenumber}',
       '%{column}',
       '%{kind}',
       '%{check}',
       '%{message}'))));
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stdout, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = explode('|', $line, 5);
 
       if (count($matches) === 5) {
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($matches[0]);
         $message->setChar($matches[1]);
         $message->setName(ucwords(str_replace('_', ' ', $matches[3])));
         $message->setDescription(ucfirst($matches[4]));
 
         switch ($matches[2]) {
           case 'warning':
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_WARNING);
             break;
 
           case 'error':
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
             break;
 
           default:
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ADVICE);
             break;
         }
 
         $messages[] = $message;
       }
     }
 
     if ($err && !$messages) {
       return false;
     }
 
     return $messages;
   }
+
 }
diff --git a/src/lint/linter/ArcanistPyLintLinter.php b/src/lint/linter/ArcanistPyLintLinter.php
index 7c5538b1..b758e8e4 100644
--- a/src/lint/linter/ArcanistPyLintLinter.php
+++ b/src/lint/linter/ArcanistPyLintLinter.php
@@ -1,268 +1,266 @@
 <?php
 
 /**
  * Uses "PyLint" to detect various errors in Python code. To use this linter,
  * you must install pylint and configure which codes you want to be reported as
  * errors, warnings and advice.
  *
  * You should be able to install pylint with ##sudo easy_install pylint##. If
  * your system is unusual, you can manually specify the location of pylint and
  * its dependencies by configuring these keys in your .arcconfig:
  *
  *   lint.pylint.prefix
  *   lint.pylint.logilab_astng.prefix
  *   lint.pylint.logilab_common.prefix
  *
  * You can specify additional command-line options to pass to PyLint by
  * setting ##lint.pylint.options##. You may also specify a list of additional
  * entries for PYTHONPATH with ##lint.pylint.pythonpath##. Those can be
  * absolute or relative to the project root.
  *
  * If you have a PyLint rcfile, specify its path with
  * ##lint.pylint.rcfile##. It can be absolute or relative to the project
  * root. Be sure not to define ##output-format##, or if you do, set it to
  * ##text##.
  *
  * Specify which PyLint messages map to which Arcanist messages by defining
  * the following regular expressions:
  *
  *   lint.pylint.codes.error
  *   lint.pylint.codes.warning
  *   lint.pylint.codes.advice
  *
  * The regexps are run in that order; the first to match determines which
  * Arcanist severity applies, if any. For example, to capture all PyLint
  * "E...." errors as Arcanist errors, set ##lint.pylint.codes.error## to:
  *
  *    ^E.*
  *
  * You can also match more granularly:
  *
  *    ^E(0001|0002)$
  *
  * According to ##man pylint##, there are 5 kind of messages:
  *
  *   (C) convention, for programming standard violation
  *   (R) refactor, for bad code smell
  *   (W) warning, for python specific problems
  *   (E) error, for probable bugs in the code
  *   (F) fatal, if an error occurred which prevented pylint from
  *       doing further processing.
- *
- * @group linter
  */
 final class ArcanistPyLintLinter extends ArcanistLinter {
 
   private function getMessageCodeSeverity($code) {
     $config = $this->getEngine()->getConfigurationManager();
 
-    $error_regexp   =
-      $config->getConfigFromAnySource('lint.pylint.codes.error');
-    $warning_regexp =
-      $config->getConfigFromAnySource('lint.pylint.codes.warning');
-    $advice_regexp  =
-      $config->getConfigFromAnySource('lint.pylint.codes.advice');
+    $error_regexp   = $config->getConfigFromAnySource(
+      'lint.pylint.codes.error');
+    $warning_regexp = $config->getConfigFromAnySource(
+      'lint.pylint.codes.warning');
+    $advice_regexp  = $config->getConfigFromAnySource(
+      'lint.pylint.codes.advice');
 
     if (!$error_regexp && !$warning_regexp && !$advice_regexp) {
       throw new ArcanistUsageException(
         "You are invoking the PyLint linter but have not configured any of ".
         "'lint.pylint.codes.error', 'lint.pylint.codes.warning', or ".
         "'lint.pylint.codes.advice'. Consult the documentation for ".
         "ArcanistPyLintLinter.");
     }
 
     $code_map = array(
       ArcanistLintSeverity::SEVERITY_ERROR    => $error_regexp,
       ArcanistLintSeverity::SEVERITY_WARNING  => $warning_regexp,
       ArcanistLintSeverity::SEVERITY_ADVICE   => $advice_regexp,
     );
 
     foreach ($code_map as $sev => $codes) {
       if ($codes === null) {
         continue;
       }
       if (!is_array($codes)) {
         $codes = array($codes);
       }
       foreach ($codes as $code_re) {
         if (preg_match("/{$code_re}/", $code)) {
           return $sev;
         }
       }
     }
 
     // If the message code doesn't match any of the provided regex's,
     // then just disable it.
     return ArcanistLintSeverity::SEVERITY_DISABLED;
   }
 
   private function getPyLintPath() {
     $pylint_bin = 'pylint';
 
     // Use the PyLint prefix specified in the config file
     $config = $this->getEngine()->getConfigurationManager();
     $prefix = $config->getConfigFromAnySource('lint.pylint.prefix');
     if ($prefix !== null) {
       $pylint_bin = $prefix.'/bin/'.$pylint_bin;
     }
 
     if (!Filesystem::pathExists($pylint_bin)) {
 
       list($err) = exec_manual('which %s', $pylint_bin);
       if ($err) {
         throw new ArcanistUsageException(
           "PyLint does not appear to be installed on this system. Install it ".
           "(e.g., with 'sudo easy_install pylint') or configure ".
           "'lint.pylint.prefix' in your .arcconfig to point to the directory ".
           "where it resides.");
       }
     }
 
     return $pylint_bin;
   }
 
   private function getPyLintPythonPath() {
     // Get non-default install locations for pylint and its dependencies
     // libraries.
     $config = $this->getEngine()->getConfigurationManager();
     $prefixes = array(
       $config->getConfigFromAnySource('lint.pylint.prefix'),
       $config->getConfigFromAnySource('lint.pylint.logilab_astng.prefix'),
       $config->getConfigFromAnySource('lint.pylint.logilab_common.prefix'),
     );
 
     // Add the libraries to the python search path
     $python_path = array();
     foreach ($prefixes as $prefix) {
       if ($prefix !== null) {
         $python_path[] = $prefix.'/lib/python2.7/site-packages';
         $python_path[] = $prefix.'/lib/python2.7/dist-packages';
         $python_path[] = $prefix.'/lib/python2.6/site-packages';
         $python_path[] = $prefix.'/lib/python2.6/dist-packages';
       }
     }
 
     $working_copy = $this->getEngine()->getWorkingCopy();
     $config_paths = $config->getConfigFromAnySource('lint.pylint.pythonpath');
     if ($config_paths !== null) {
       foreach ($config_paths as $config_path) {
         if ($config_path !== null) {
           $python_path[] = Filesystem::resolvePath(
             $config_path,
             $working_copy->getProjectRoot());
         }
       }
     }
 
     $python_path[] = '';
     return implode(':', $python_path);
   }
 
   private function getPyLintOptions() {
     // '-rn': don't print lint report/summary at end
     $options = array('-rn');
 
     // Version 0.x.x include the pylint message ids in the output
     if (version_compare($this->getLinterVersion(), '1', 'lt')) {
       array_push($options, '-iy', '--output-format=text');
     }
     // Version 1.x.x set the output specifically to the 0.x.x format
     else {
       array_push($options, "--msg-template='{msg_id}:{line:3d}: {obj}: {msg}'");
     }
 
     $working_copy = $this->getEngine()->getWorkingCopy();
     $config = $this->getEngine()->getConfigurationManager();
 
     // Specify an --rcfile, either absolute or relative to the project root.
     // Stupidly, the command line args above are overridden by rcfile, so be
     // careful.
     $rcfile = $config->getConfigFromAnySource('lint.pylint.rcfile');
     if ($rcfile !== null) {
       $rcfile = Filesystem::resolvePath(
         $rcfile,
         $working_copy->getProjectRoot());
       $options[] = csprintf('--rcfile=%s', $rcfile);
     }
 
     // Add any options defined in the config file for PyLint
     $config_options = $config->getConfigFromAnySource('lint.pylint.options');
     if ($config_options !== null) {
       $options = array_merge($options, $config_options);
     }
 
     return implode(' ', $options);
   }
 
   public function getLinterName() {
     return 'PyLint';
   }
 
   private function getLinterVersion() {
     $pylint_bin = $this->getPyLintPath();
     $options = '--version';
 
     list($stdout) = execx('%s %s', $pylint_bin, $options);
 
     $lines = phutil_split_lines($stdout, false);
     $matches = null;
 
     // If the version command didn't return anything or the regex didn't match
     // Assume a future version that at least is compatible with 1.x.x
     if (count($lines) == 0 ||
         !preg_match('/pylint\s((?:\d+\.?)+)/', $lines[0], $matches)) {
       return '999';
     }
 
     return $matches[1];
   }
 
   public function lintPath($path) {
     $pylint_bin = $this->getPyLintPath();
     $python_path = $this->getPyLintPythonPath();
     $options = $this->getPyLintOptions();
     $path_on_disk = $this->getEngine()->getFilePathOnDisk($path);
 
     try {
       list($stdout, $_) = execx(
         '/usr/bin/env PYTHONPATH=%s$PYTHONPATH %s %C %s',
         $python_path,
         $pylint_bin,
         $options,
         $path_on_disk);
     } catch (CommandException $e) {
       if ($e->getError() == 32) {
         // According to ##man pylint## the exit status of 32 means there was a
         // usage error. That's bad, so actually exit abnormally.
         throw $e;
       } else {
         // The other non-zero exit codes mean there were messages issued,
         // which is expected, so don't exit.
         $stdout = $e->getStdout();
       }
     }
 
     $lines = phutil_split_lines($stdout, false);
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       $regex = '/([A-Z]\d+): *(\d+)(?:|,\d*): *(.*)$/';
       if (!preg_match($regex, $line, $matches)) {
         continue;
       }
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
 
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[2]);
       $message->setCode($matches[1]);
       $message->setName($this->getLinterName().' '.$matches[1]);
       $message->setDescription($matches[3]);
       $message->setSeverity($this->getMessageCodeSeverity($matches[1]));
       $this->addLintMessage($message);
     }
   }
 
 }
diff --git a/src/lint/linter/ArcanistScriptAndRegexLinter.php b/src/lint/linter/ArcanistScriptAndRegexLinter.php
index 1c12ff0d..22e88b89 100644
--- a/src/lint/linter/ArcanistScriptAndRegexLinter.php
+++ b/src/lint/linter/ArcanistScriptAndRegexLinter.php
@@ -1,409 +1,407 @@
 <?php
 
 /**
  * Simple glue linter which runs some script on each path, and then uses a
  * regex to parse lint messages from the script's output. (This linter uses a
  * script and a regex to interpret the results of some real linter, it does
  * not itself lint both scripts and regexes).
  *
  * Configure this linter by setting these keys in your configuration:
  *
  *  - `linter.scriptandregex.script` Script command to run. This can be
  *    the path to a linter script, but may also include flags or use shell
  *    features (see below for examples).
  *  - `linter.scriptandregex.regex` The regex to process output with. This
  *    regex uses named capturing groups (detailed below) to interpret output.
  *
  * The script will be invoked from the project root, so you can specify a
  * relative path like `scripts/lint.sh` or an absolute path like
  * `/opt/lint/lint.sh`.
  *
  * This linter is necessarily more limited in its capabilities than a normal
  * linter which can perform custom processing, but may be somewhat simpler to
  * configure.
  *
  * == Script... ==
  *
  * The script will be invoked once for each file that is to be linted, with
  * the file passed as the first argument. The file may begin with a "-"; ensure
  * your script will not interpret such files as flags (perhaps by ending your
  * script configuration with "--", if its argument parser supports that).
  *
  * Note that when run via `arc diff`, the list of files to be linted includes
  * deleted files and files that were moved away by the change. The linter should
  * not assume the path it is given exists, and it is not an error for the
  * linter to be invoked with paths which are no longer there. (Every affected
  * path is subject to lint because some linters may raise errors in other files
  * when a file is removed, or raise an error about its removal.)
  *
  * The script should emit lint messages to stdout, which will be parsed with
  * the provided regex.
  *
  * For example, you might use a configuration like this:
  *
  *   /opt/lint/lint.sh --flag value --other-flag --
  *
  * stderr is ignored. If you have a script which writes messages to stderr,
  * you can redirect stderr to stdout by using a configuration like this:
  *
  *   sh -c '/opt/lint/lint.sh "$0" 2>&1'
  *
  * The return code of the script must be 0, or an exception will be raised
  * reporting that the linter failed. If you have a script which exits nonzero
  * under normal circumstances, you can force it to always exit 0 by using a
  * configuration like this:
  *
  *   sh -c '/opt/lint/lint.sh "$0" || true'
  *
  * Multiple instances of the script will be run in parallel if there are
  * multiple files to be linted, so they should not use any unique resources.
  * For instance, this configuration would not work properly, because several
  * processes may attempt to write to the file at the same time:
  *
  *   COUNTEREXAMPLE
  *   sh -c '/opt/lint/lint.sh --output /tmp/lint.out "$0" && cat /tmp/lint.out'
  *
  * There are necessary limits to how gracefully this linter can deal with
  * edge cases, because it is just a script and a regex. If you need to do
  * things that this linter can't handle, you can write a phutil linter and move
  * the logic to handle those cases into PHP. PHP is a better general-purpose
  * programming language than regular expressions are, if only by a small margin.
  *
  * == ...and Regex ==
  *
  * The regex must be a valid PHP PCRE regex, including delimiters and flags.
  *
  * The regex will be matched against the entire output of the script, so it
  * should generally be in this form if messages are one-per-line:
  *
  *   /^...$/m
  *
  * The regex should capture these named patterns with `(?P<name>...)`:
  *
  *   - `message` (required) Text describing the lint message. For example,
  *     "This is a syntax error.".
  *   - `name` (optional) Text summarizing the lint message. For example,
  *     "Syntax Error".
  *   - `severity` (optional) The word "error", "warning", "autofix", "advice",
  *     or "disabled", in any combination of upper and lower case. Instead, you
  *     may match groups called `error`, `warning`, `advice`, `autofix`, or
  *     `disabled`. These allow you to match output formats like "E123" and
  *     "W123" to indicate errors and warnings, even though the word "error" is
  *     not present in the output. If no severity capturing group is present,
  *     messages are raised with "error" severity. If multiple severity capturing
  *     groups are present, messages are raised with the highest captured
  *     serverity. Capturing groups like `error` supersede the `severity`
  *     capturing group.
  *   - `error` (optional) Match some nonempty substring to indicate that this
  *     message has "error" severity.
  *   - `warning` (optional) Match some nonempty substring to indicate that this
  *     message has "warning" severity.
  *   - `advice` (optional) Match some nonempty substring to indicate that this
  *     message has "advice" severity.
  *   - `autofix` (optional) Match some nonempty substring to indicate that this
  *     message has "autofix" severity.
  *   - `disabled` (optional) Match some nonempty substring to indicate that this
  *     message has "disabled" severity.
  *   - `file` (optional) The name of the file to raise the lint message in. If
  *     not specified, defaults to the linted file. It is generally not necessary
  *     to capture this unless the linter can raise messages in files other than
  *     the one it is linting.
  *   - `line` (optional) The line number of the message.
  *   - `char` (optional) The character offset of the message.
  *   - `offset` (optional) The byte offset of the message. If captured, this
  *     supersedes `line` and `char`.
  *   - `original` (optional) The text the message affects.
  *   - `replacement` (optional) The text that the range captured by `original`
  *     should be automatically replaced by to resolve the message.
  *   - `code` (optional) A short error type identifier which can be used
  *     elsewhere to configure handling of specific types of messages. For
  *     example, "EXAMPLE1", "EXAMPLE2", etc., where each code identifies a
  *     class of message like "syntax error", "missing whitespace", etc. This
  *     allows configuration to later change the severity of all whitespace
  *     messages, for example.
  *   - `ignore` (optional) Match some nonempty substring to ignore the match.
  *     You can use this if your linter sometimes emits text like "No lint
  *     errors".
  *   - `stop` (optional) Match some nonempty substring to stop processing input.
  *     Remaining matches for this file will be discarded, but linting will
  *     continue with other linters and other files.
  *   - `halt` (optional) Match some nonempty substring to halt all linting of
  *     this file by any linter. Linting will continue with other files.
  *   - `throw` (optional) Match some nonempty substring to throw an error, which
  *     will stop `arc` completely. You can use this to fail abruptly if you
  *     encounter unexpected output. All processing will abort.
  *
  * Numbered capturing groups are ignored.
  *
  * For example, if your lint script's output looks like this:
  *
  *   error:13 Too many goats!
  *   warning:22 Not enough boats.
  *
  * ...you could use this regex to parse it:
  *
  *   /^(?P<severity>warning|error):(?P<line>\d+) (?P<message>.*)$/m
  *
  * The simplest valid regex for line-oriented output is something like this:
  *
  *   /^(?P<message>.*)$/m
  *
  * @task  lint        Linting
  * @task  linterinfo  Linter Information
  * @task  parse       Parsing Output
  * @task  config      Validating Configuration
- *
- * @group linter
  */
 final class ArcanistScriptAndRegexLinter extends ArcanistLinter {
 
   private $output = array();
 
   public function getInfoName() {
     return pht('Script and Regex');
   }
 
   public function getInfoDescription() {
     return pht(
       'Run an external script, then parse its output with a regular '.
       'expression. This is a generic binding that can be used to '.
       'run custom lint scripts.');
   }
 
 /* -(  Linting  )------------------------------------------------------------ */
 
 
   /**
    * Run the script on each file to be linted.
    *
    * @task lint
    */
   public function willLintPaths(array $paths) {
     $script = $this->getConfiguredScript();
     $root   = $this->getEngine()->getWorkingCopy()->getProjectRoot();
 
     $futures = array();
     foreach ($paths as $path) {
       $future = new ExecFuture('%C %s', $script, $path);
       $future->setCWD($root);
       $futures[$path] = $future;
     }
 
     foreach (Futures($futures)->limit(4) as $path => $future) {
       list($stdout) = $future->resolvex();
       $this->output[$path] = $stdout;
     }
   }
 
   /**
    * Run the regex on the output of the script.
    *
    * @task lint
    */
   public function lintPath($path) {
     $regex = $this->getConfiguredRegex();
 
     $output = idx($this->output, $path);
     if (!strlen($output)) {
       // No output, but it exited 0, so just move on.
       return;
     }
 
     $matches = null;
     if (!preg_match_all($regex, $output, $matches, PREG_SET_ORDER)) {
       // Output with no matches. This might be a configuration error, but more
       // likely it's something like "No lint errors." and the user just hasn't
       // written a sufficiently powerful/ridiculous regexp to capture it into an
       // 'ignore' group. Don't make them figure this out; advanced users can
       // capture 'throw' to handle this case.
       return;
     }
 
     foreach ($matches as $match) {
       if (!empty($match['throw'])) {
         $throw = $match['throw'];
         throw new ArcanistUsageException(
           "ArcanistScriptAndRegexLinter: ".
           "configuration captured a 'throw' named capturing group, ".
           "'{$throw}'. Script output:\n".
           $output);
       }
 
       if (!empty($match['halt'])) {
         $this->stopAllLinters();
         break;
       }
 
       if (!empty($match['stop'])) {
         break;
       }
 
       if (!empty($match['ignore'])) {
         continue;
       }
 
       list($line, $char) = $this->getMatchLineAndChar($match, $path);
 
       $dict = array(
         'path'        => idx($match, 'file', $path),
         'line'        => $line,
         'char'        => $char,
         'code'        => idx($match, 'code', $this->getLinterName()),
         'severity'    => $this->getMatchSeverity($match),
         'name'        => idx($match, 'name', 'Lint'),
         'description' => idx($match, 'message', 'Undefined Lint Message'),
       );
 
       $original = idx($match, 'original');
       if ($original !== null) {
         $dict['original'] = $original;
       }
 
       $replacement = idx($match, 'replacement');
       if ($replacement !== null) {
         $dict['replacement'] = $replacement;
       }
 
       $lint = ArcanistLintMessage::newFromDictionary($dict);
       $this->addLintMessage($lint);
     }
   }
 
 
 /* -(  Linter Information  )------------------------------------------------- */
 
   /**
    * Return the short name of the linter.
    *
    * @return string Short linter identifier.
    *
    * @task linterinfo
    */
   public function getLinterName() {
     return 'S&RX';
   }
 
   public function getLinterConfigurationName() {
     return 'script-and-regex';
   }
 
 
 /* -(  Parsing Output  )----------------------------------------------------- */
 
   /**
    * Get the line and character of the message from the regex match.
    *
    * @param dict Captured groups from regex.
    * @return pair<int,int> Line and character of the message.
    *
    * @task parse
    */
   private function getMatchLineAndChar(array $match, $path) {
     if (!empty($match['offset'])) {
       list($line, $char) = $this->getEngine()->getLineAndCharFromOffset(
         idx($match, 'file', $path),
         $match['offset']);
       return array($line + 1, $char + 1);
     }
 
     $line = idx($match, 'line', 1);
     $char = idx($match, 'char');
 
     return array($line, $char);
   }
 
   /**
    * Map the regex matching groups to a message severity. We look for either
    * a nonempty severity name group like 'error', or a group called 'severity'
    * with a valid name.
    *
    * @param dict Captured groups from regex.
    * @return const  @{class:ArcanistLintSeverity} constant.
    *
    * @task parse
    */
   private function getMatchSeverity(array $match) {
     $map = array(
       'error'    => ArcanistLintSeverity::SEVERITY_ERROR,
       'warning'  => ArcanistLintSeverity::SEVERITY_WARNING,
       'autofix'  => ArcanistLintSeverity::SEVERITY_AUTOFIX,
       'advice'   => ArcanistLintSeverity::SEVERITY_ADVICE,
       'disabled' => ArcanistLintSeverity::SEVERITY_DISABLED,
     );
 
     $severity_name = strtolower(idx($match, 'severity'));
 
     foreach ($map as $name => $severity) {
       if (!empty($match[$name])) {
         return $severity;
       } else if ($severity_name == $name) {
         return $severity;
       }
     }
 
     return ArcanistLintSeverity::SEVERITY_ERROR;
   }
 
 
 /* -(  Validating Configuration  )------------------------------------------- */
 
   /**
    * Load, validate, and return the "script" configuration.
    *
    * @return string The shell command fragment to use to run the linter.
    *
    * @task config
    */
   private function getConfiguredScript() {
     $key = 'linter.scriptandregex.script';
     $config = $this->getEngine()
       ->getConfigurationManager()
       ->getConfigFromAnySource($key);
 
     if (!$config) {
       throw new ArcanistUsageException(
         "ArcanistScriptAndRegexLinter: ".
         "You must configure '{$key}' to point to a script to execute.");
     }
 
     // NOTE: No additional validation since the "script" can be some random
     // shell command and/or include flags, so it does not need to point to some
     // file on disk.
 
     return $config;
   }
 
   /**
    * Load, validate, and return the "regex" configuration.
    *
    * @return string A valid PHP PCRE regular expression.
    *
    * @task config
    */
   private function getConfiguredRegex() {
     $key = 'linter.scriptandregex.regex';
     $config = $this->getEngine()
       ->getConfigurationManager()
       ->getConfigFromAnySource($key);
 
     if (!$config) {
       throw new ArcanistUsageException(
         "ArcanistScriptAndRegexLinter: ".
         "You must configure '{$key}' with a valid PHP PCRE regex.");
     }
 
     // NOTE: preg_match() returns 0 for no matches and false for compile error;
     // this won't match, but will validate the syntax of the regex.
 
     $ok = preg_match($config, 'syntax-check');
     if ($ok === false) {
       throw new ArcanistUsageException(
         "ArcanistScriptAndRegexLinter: ".
         "Regex '{$config}' does not compile. You must configure '{$key}' with ".
         "a valid PHP PCRE regex, including delimiters.");
     }
 
     return $config;
   }
 
 }
diff --git a/src/lint/linter/ArcanistXHPASTLinter.php b/src/lint/linter/ArcanistXHPASTLinter.php
index 6b3309d0..552500d0 100644
--- a/src/lint/linter/ArcanistXHPASTLinter.php
+++ b/src/lint/linter/ArcanistXHPASTLinter.php
@@ -1,2542 +1,2542 @@
 <?php
 
 /**
  * Uses XHPAST to apply lint rules to PHP.
  */
 final class ArcanistXHPASTLinter extends ArcanistBaseXHPASTLinter {
 
   const LINT_PHP_SYNTAX_ERROR          = 1;
   const LINT_UNABLE_TO_PARSE           = 2;
   const LINT_VARIABLE_VARIABLE         = 3;
   const LINT_EXTRACT_USE               = 4;
   const LINT_UNDECLARED_VARIABLE       = 5;
   const LINT_PHP_SHORT_TAG             = 6;
   const LINT_PHP_ECHO_TAG              = 7;
   const LINT_PHP_CLOSE_TAG             = 8;
   const LINT_NAMING_CONVENTIONS        = 9;
   const LINT_IMPLICIT_CONSTRUCTOR      = 10;
   const LINT_DYNAMIC_DEFINE            = 12;
   const LINT_STATIC_THIS               = 13;
   const LINT_PREG_QUOTE_MISUSE         = 14;
   const LINT_PHP_OPEN_TAG              = 15;
   const LINT_TODO_COMMENT              = 16;
   const LINT_EXIT_EXPRESSION           = 17;
   const LINT_COMMENT_STYLE             = 18;
   const LINT_CLASS_FILENAME_MISMATCH   = 19;
   const LINT_TAUTOLOGICAL_EXPRESSION   = 20;
   const LINT_PLUS_OPERATOR_ON_STRINGS  = 21;
   const LINT_DUPLICATE_KEYS_IN_ARRAY   = 22;
   const LINT_REUSED_ITERATORS          = 23;
   const LINT_BRACE_FORMATTING          = 24;
   const LINT_PARENTHESES_SPACING       = 25;
   const LINT_CONTROL_STATEMENT_SPACING = 26;
   const LINT_BINARY_EXPRESSION_SPACING = 27;
   const LINT_ARRAY_INDEX_SPACING       = 28;
   const LINT_IMPLICIT_FALLTHROUGH      = 30;
   const LINT_REUSED_AS_ITERATOR        = 32;
   const LINT_COMMENT_SPACING           = 34;
   const LINT_SLOWNESS                  = 36;
   const LINT_CLOSING_CALL_PAREN        = 37;
   const LINT_CLOSING_DECL_PAREN        = 38;
   const LINT_REUSED_ITERATOR_REFERENCE = 39;
   const LINT_KEYWORD_CASING            = 40;
   const LINT_DOUBLE_QUOTE              = 41;
   const LINT_ELSEIF_USAGE              = 42;
   const LINT_SEMICOLON_SPACING         = 43;
   const LINT_CONCATENATION_OPERATOR    = 44;
   const LINT_PHP_COMPATIBILITY         = 45;
 
   private $naminghook;
   private $switchhook;
   private $version;
   private $windowsVersion;
 
   public function getInfoName() {
     return 'XHPAST Lint';
   }
 
   public function getInfoDescription() {
     return pht(
       'Use XHPAST to enforce Phabricator coding conventions on PHP source '.
       'files. This linter is intended for use in Phabricator libraries and '.
       'extensions, and enforces some Phabricator-specific style rules. It '.
       'may not work well for general PHP source.');
   }
 
   public function getLintNameMap() {
     return array(
       self::LINT_PHP_SYNTAX_ERROR          => 'PHP Syntax Error!',
       self::LINT_UNABLE_TO_PARSE           => 'Unable to Parse',
       self::LINT_VARIABLE_VARIABLE         => 'Use of Variable Variable',
       self::LINT_EXTRACT_USE               => 'Use of extract()',
       self::LINT_UNDECLARED_VARIABLE       => 'Use of Undeclared Variable',
       self::LINT_PHP_SHORT_TAG             => 'Use of Short Tag "<?"',
       self::LINT_PHP_ECHO_TAG              => 'Use of Echo Tag "<?="',
       self::LINT_PHP_CLOSE_TAG             => 'Use of Close Tag "?>"',
       self::LINT_NAMING_CONVENTIONS        => 'Naming Conventions',
       self::LINT_IMPLICIT_CONSTRUCTOR      => 'Implicit Constructor',
       self::LINT_DYNAMIC_DEFINE            => 'Dynamic define()',
       self::LINT_STATIC_THIS               => 'Use of $this in Static Context',
       self::LINT_PREG_QUOTE_MISUSE         => 'Misuse of preg_quote()',
       self::LINT_PHP_OPEN_TAG              => 'Expected Open Tag',
       self::LINT_TODO_COMMENT              => 'TODO Comment',
       self::LINT_EXIT_EXPRESSION           => 'Exit Used as Expression',
       self::LINT_COMMENT_STYLE             => 'Comment Style',
       self::LINT_CLASS_FILENAME_MISMATCH   => 'Class-Filename Mismatch',
       self::LINT_TAUTOLOGICAL_EXPRESSION   => 'Tautological Expression',
       self::LINT_PLUS_OPERATOR_ON_STRINGS  => 'Not String Concatenation',
       self::LINT_DUPLICATE_KEYS_IN_ARRAY   => 'Duplicate Keys in Array',
       self::LINT_REUSED_ITERATORS          => 'Reuse of Iterator Variable',
       self::LINT_BRACE_FORMATTING          => 'Brace placement',
       self::LINT_PARENTHESES_SPACING       => 'Spaces Inside Parentheses',
       self::LINT_CONTROL_STATEMENT_SPACING => 'Space After Control Statement',
       self::LINT_BINARY_EXPRESSION_SPACING => 'Space Around Binary Operator',
       self::LINT_ARRAY_INDEX_SPACING       => 'Spacing Before Array Index',
       self::LINT_IMPLICIT_FALLTHROUGH      => 'Implicit Fallthrough',
       self::LINT_REUSED_AS_ITERATOR        => 'Variable Reused As Iterator',
       self::LINT_COMMENT_SPACING           => 'Comment Spaces',
       self::LINT_SLOWNESS                  => 'Slow Construct',
       self::LINT_CLOSING_CALL_PAREN        => 'Call Formatting',
       self::LINT_CLOSING_DECL_PAREN        => 'Declaration Formatting',
       self::LINT_REUSED_ITERATOR_REFERENCE => 'Reuse of Iterator References',
       self::LINT_KEYWORD_CASING            => 'Keyword Conventions',
       self::LINT_DOUBLE_QUOTE              => 'Unnecessary Double Quotes',
       self::LINT_ELSEIF_USAGE              => 'ElseIf Usage',
       self::LINT_SEMICOLON_SPACING         => 'Semicolon Spacing',
       self::LINT_CONCATENATION_OPERATOR    => 'Concatenation Spacing',
       self::LINT_PHP_COMPATIBILITY         => 'PHP Compatibility',
     );
   }
 
   public function getLinterName() {
     return 'XHP';
   }
 
   public function getLinterConfigurationName() {
     return 'xhpast';
   }
 
   public function getLintSeverityMap() {
     $disabled = ArcanistLintSeverity::SEVERITY_DISABLED;
     $advice   = ArcanistLintSeverity::SEVERITY_ADVICE;
     $warning  = ArcanistLintSeverity::SEVERITY_WARNING;
 
     return array(
       self::LINT_TODO_COMMENT              => $disabled,
       self::LINT_UNABLE_TO_PARSE           => $warning,
       self::LINT_NAMING_CONVENTIONS        => $warning,
       self::LINT_PREG_QUOTE_MISUSE         => $advice,
       self::LINT_BRACE_FORMATTING          => $warning,
       self::LINT_PARENTHESES_SPACING       => $warning,
       self::LINT_CONTROL_STATEMENT_SPACING => $warning,
       self::LINT_BINARY_EXPRESSION_SPACING => $warning,
       self::LINT_ARRAY_INDEX_SPACING       => $warning,
       self::LINT_IMPLICIT_FALLTHROUGH      => $warning,
       self::LINT_SLOWNESS                  => $warning,
       self::LINT_COMMENT_SPACING           => $advice,
       self::LINT_CLOSING_CALL_PAREN        => $warning,
       self::LINT_CLOSING_DECL_PAREN        => $warning,
       self::LINT_REUSED_ITERATOR_REFERENCE => $warning,
       self::LINT_KEYWORD_CASING            => $warning,
       self::LINT_DOUBLE_QUOTE              => $advice,
       self::LINT_ELSEIF_USAGE              => $advice,
       self::LINT_SEMICOLON_SPACING         => $advice,
       self::LINT_CONCATENATION_OPERATOR    => $warning,
     );
   }
 
   public function getLinterConfigurationOptions() {
     return parent::getLinterConfigurationOptions() + array(
       'xhpast.naminghook' => array(
         'type' => 'optional string',
         'help' => pht(
           'Name of a concrete subclass of ArcanistXHPASTLintNamingHook which '.
           'enforces more granular naming convention rules for symbols.'),
       ),
       'xhpast.switchhook' => array(
         'type' => 'optional string',
         'help' => pht(
           'Name of a concrete subclass of ArcanistXHPASTLintSwitchHook which '.
           'tunes the analysis of switch() statements for this linter.'),
       ),
       'xhpast.php-version' => array(
         'type' => 'optional string',
         'help' => pht('PHP version to target.'),
       ),
       'xhpast.php-version.windows' => array(
         'type' => 'optional string',
         'help' => pht('PHP version to target on Windows.'),
       ),
     );
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'xhpast.naminghook':
         $this->naminghook = $value;
         return;
       case 'xhpast.switchhook':
         $this->switchhook = $value;
         return;
       case 'xhpast.php-version':
         $this->version = $value;
         return;
       case 'xhpast.php-version.windows':
         $this->windowsVersion = $value;
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   public function getVersion() {
     // The version number should be incremented whenever a new rule is added.
     return '7';
   }
 
   protected function resolveFuture($path, Future $future) {
     $tree = $this->getXHPASTTreeForPath($path);
     if (!$tree) {
       $ex = $this->getXHPASTExceptionForPath($path);
       if ($ex instanceof XHPASTSyntaxErrorException) {
         $this->raiseLintAtLine(
           $ex->getErrorLine(),
           1,
           self::LINT_PHP_SYNTAX_ERROR,
           'This file contains a syntax error: '.$ex->getMessage());
       } else if ($ex instanceof Exception) {
         $this->raiseLintAtPath(self::LINT_UNABLE_TO_PARSE, $ex->getMessage());
       }
       return;
     }
 
     $root = $tree->getRootNode();
 
     $method_codes = array(
       'lintStrstrUsedForCheck' => self::LINT_SLOWNESS,
       'lintStrposUsedForStart' => self::LINT_SLOWNESS,
       'lintImplicitFallthrough' => self::LINT_IMPLICIT_FALLTHROUGH,
       'lintBraceFormatting' => self::LINT_BRACE_FORMATTING,
       'lintTautologicalExpressions' => self::LINT_TAUTOLOGICAL_EXPRESSION,
       'lintCommentSpaces' => self::LINT_COMMENT_SPACING,
       'lintHashComments' => self::LINT_COMMENT_STYLE,
       'lintReusedIterators' => self::LINT_REUSED_ITERATORS,
       'lintReusedIteratorReferences' => self::LINT_REUSED_ITERATOR_REFERENCE,
       'lintVariableVariables' => self::LINT_VARIABLE_VARIABLE,
       'lintUndeclaredVariables' => array(
         self::LINT_EXTRACT_USE,
         self::LINT_REUSED_AS_ITERATOR,
         self::LINT_UNDECLARED_VARIABLE,
       ),
       'lintPHPTagUse' => array(
         self::LINT_PHP_SHORT_TAG,
         self::LINT_PHP_ECHO_TAG,
         self::LINT_PHP_OPEN_TAG,
         self::LINT_PHP_CLOSE_TAG,
       ),
       'lintNamingConventions' => self::LINT_NAMING_CONVENTIONS,
       'lintSurpriseConstructors' => self::LINT_IMPLICIT_CONSTRUCTOR,
       'lintParenthesesShouldHugExpressions' => self::LINT_PARENTHESES_SPACING,
       'lintSpaceAfterControlStatementKeywords' =>
         self::LINT_CONTROL_STATEMENT_SPACING,
       'lintSpaceAroundBinaryOperators' => self::LINT_BINARY_EXPRESSION_SPACING,
       'lintDynamicDefines' => self::LINT_DYNAMIC_DEFINE,
       'lintUseOfThisInStaticMethods' => self::LINT_STATIC_THIS,
       'lintPregQuote' => self::LINT_PREG_QUOTE_MISUSE,
       'lintExitExpressions' => self::LINT_EXIT_EXPRESSION,
       'lintArrayIndexWhitespace' => self::LINT_ARRAY_INDEX_SPACING,
       'lintTODOComments' => self::LINT_TODO_COMMENT,
       'lintPrimaryDeclarationFilenameMatch' =>
         self::LINT_CLASS_FILENAME_MISMATCH,
       'lintPlusOperatorOnStrings' => self::LINT_PLUS_OPERATOR_ON_STRINGS,
       'lintDuplicateKeysInArray' => self::LINT_DUPLICATE_KEYS_IN_ARRAY,
       'lintClosingCallParen' => self::LINT_CLOSING_CALL_PAREN,
       'lintClosingDeclarationParen' => self::LINT_CLOSING_DECL_PAREN,
       'lintKeywordCasing' => self::LINT_KEYWORD_CASING,
       'lintStrings' => self::LINT_DOUBLE_QUOTE,
       'lintElseIfStatements' => self::LINT_ELSEIF_USAGE,
       'lintSemicolons' => self::LINT_SEMICOLON_SPACING,
       'lintSpaceAroundConcatenationOperators' =>
         self::LINT_CONCATENATION_OPERATOR,
       'lintPHPCompatibility' => self::LINT_PHP_COMPATIBILITY,
     );
 
     foreach ($method_codes as $method => $codes) {
       foreach ((array)$codes as $code) {
         if ($this->isCodeEnabled($code)) {
           call_user_func(array($this, $method), $root);
           break;
         }
       }
     }
   }
 
   private function lintStrstrUsedForCheck(XHPASTNode $root) {
     $expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
     foreach ($expressions as $expression) {
       $operator = $expression->getChildOfType(1, 'n_OPERATOR');
       $operator = $operator->getConcreteString();
 
       if ($operator != '===' && $operator != '!==') {
         continue;
       }
 
       $false = $expression->getChildByIndex(0);
       if ($false->getTypeName() == 'n_SYMBOL_NAME' &&
           $false->getConcreteString() == 'false') {
         $strstr = $expression->getChildByIndex(2);
       } else {
         $strstr = $false;
         $false = $expression->getChildByIndex(2);
         if ($false->getTypeName() != 'n_SYMBOL_NAME' ||
             $false->getConcreteString() != 'false') {
           continue;
         }
       }
 
       if ($strstr->getTypeName() != 'n_FUNCTION_CALL') {
         continue;
       }
 
       $name = strtolower($strstr->getChildByIndex(0)->getConcreteString());
       if ($name == 'strstr' || $name == 'strchr') {
         $this->raiseLintAtNode(
           $strstr,
           self::LINT_SLOWNESS,
           'Use strpos() for checking if the string contains something.');
       } else if ($name == 'stristr') {
         $this->raiseLintAtNode(
           $strstr,
           self::LINT_SLOWNESS,
           'Use stripos() for checking if the string contains something.');
       }
     }
   }
 
   private function lintStrposUsedForStart(XHPASTNode $root) {
     $expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
     foreach ($expressions as $expression) {
       $operator = $expression->getChildOfType(1, 'n_OPERATOR');
       $operator = $operator->getConcreteString();
 
       if ($operator != '===' && $operator != '!==') {
         continue;
       }
 
       $zero = $expression->getChildByIndex(0);
       if ($zero->getTypeName() == 'n_NUMERIC_SCALAR' &&
           $zero->getConcreteString() == '0') {
         $strpos = $expression->getChildByIndex(2);
       } else {
         $strpos = $zero;
         $zero = $expression->getChildByIndex(2);
         if ($zero->getTypeName() != 'n_NUMERIC_SCALAR' ||
             $zero->getConcreteString() != '0') {
           continue;
         }
       }
 
       if ($strpos->getTypeName() != 'n_FUNCTION_CALL') {
         continue;
       }
 
       $name = strtolower($strpos->getChildByIndex(0)->getConcreteString());
       if ($name == 'strpos') {
         $this->raiseLintAtNode(
           $strpos,
           self::LINT_SLOWNESS,
           'Use strncmp() for checking if the string starts with something.');
       } else if ($name == 'stripos') {
         $this->raiseLintAtNode(
           $strpos,
           self::LINT_SLOWNESS,
           'Use strncasecmp() for checking if the string starts with '.
             'something.');
       }
     }
   }
 
   private function lintPHPCompatibility(XHPASTNode $root) {
     if (!$this->version) {
       return;
     }
 
     $target = phutil_get_library_root('phutil').
       '/../resources/php_compat_info.json';
     $compat_info = phutil_json_decode(Filesystem::readFile($target));
 
     $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
     foreach ($calls as $call) {
       $node = $call->getChildByIndex(0);
       $name = $node->getConcreteString();
       $version = idx($compat_info['functions'], $name);
 
       if ($version && version_compare($version['min'], $this->version, '>')) {
         $this->raiseLintAtNode(
           $node,
           self::LINT_PHP_COMPATIBILITY,
           "This codebase targets PHP {$this->version}, but `{$name}()` was ".
           "not introduced until PHP {$version['min']}.");
       } else if (array_key_exists($name, $compat_info['params'])) {
         $params = $call->getChildOfType(1, 'n_CALL_PARAMETER_LIST');
         foreach (array_values($params->getChildren()) as $i => $param) {
           $version = idx($compat_info['params'][$name], $i);
           if ($version && version_compare($version, $this->version, '>')) {
             $this->raiseLintAtNode(
               $param,
               self::LINT_PHP_COMPATIBILITY,
               "This codebase targets PHP {$this->version}, but parameter ".
               ($i + 1)." of `{$name}()` was not introduced until PHP ".
               "{$version}.");
           }
         }
       }
 
       if ($this->windowsVersion) {
         $windows = idx($compat_info['functions_windows'], $name);
 
         if ($windows === false) {
           $this->raiseLintAtNode(
             $node,
             self::LINT_PHP_COMPATIBILITY,
             "This codebase targets PHP {$this->windowsVersion} on Windows, ".
             "but `{$name}()` is not available there.");
         } else if (version_compare($windows, $this->windowsVersion, '>')) {
           $this->raiseLintAtNode(
             $node,
             self::LINT_PHP_COMPATIBILITY,
             "This codebase targets PHP {$this->windowsVersion} on Windows, ".
             "but `{$name}()` is not available there until PHP ".
             "{$this->windowsVersion}.");
         }
       }
     }
 
     $classes = $root->selectDescendantsOfType('n_CLASS_NAME');
     foreach ($classes as $node) {
       $name = $node->getConcreteString();
       $version = idx($compat_info['interfaces'], $name);
       $version = idx($compat_info['classes'], $name, $version);
       if ($version && version_compare($version['min'], $this->version, '>')) {
         $this->raiseLintAtNode(
           $node,
           self::LINT_PHP_COMPATIBILITY,
           "This codebase targets PHP {$this->version}, but `{$name}` was not ".
           "introduced until PHP {$version['min']}.");
       }
     }
 
     // TODO: Technically, this will include function names. This is unlikely to
     // cause any issues (unless, of course, there existed a function that had
     // the same name as some constant).
     $constants = $root->selectDescendantsOfType('n_SYMBOL_NAME');
     foreach ($constants as $node) {
       $name = $node->getConcreteString();
       $version = idx($compat_info['constants'], $name);
       if ($version && version_compare($version['min'], $this->version, '>')) {
         $this->raiseLintAtNode(
           $node,
           self::LINT_PHP_COMPATIBILITY,
           "This codebase targets PHP {$this->version}, but `{$name}` was not ".
           "introduced until PHP {$version['min']}.");
       }
     }
 
     if (version_compare($this->version, '5.3.0') < 0) {
       $this->lintPHP53Features($root);
     }
 
     if (version_compare($this->version, '5.4.0') < 0) {
       $this->lintPHP54Features($root);
     }
   }
 
   private function lintPHP53Features(XHPASTNode $root) {
     $functions = $root->selectTokensOfType('T_FUNCTION');
     foreach ($functions as $function) {
       $next = $function->getNextToken();
       while ($next) {
         if ($next->isSemantic()) {
           break;
         }
         $next = $next->getNextToken();
       }
 
       if ($next) {
         if ($next->getTypeName() == '(') {
           $this->raiseLintAtToken(
             $function,
             self::LINT_PHP_COMPATIBILITY,
             "This codebase targets PHP {$this->version}, but anonymous ".
             "functions were not introduced until PHP 5.3.");
         }
       }
     }
 
     $namespaces = $root->selectTokensOfType('T_NAMESPACE');
     foreach ($namespaces as $namespace) {
       $this->raiseLintAtToken(
         $namespace,
         self::LINT_PHP_COMPATIBILITY,
         "This codebase targets PHP {$this->version}, but namespaces were not ".
         "introduced until PHP 5.3.");
     }
 
     // NOTE: This is only "use x;", in anonymous functions the node type is
     // n_LEXICAL_VARIABLE_LIST even though both tokens are T_USE.
 
     // TODO: We parse n_USE in a slightly crazy way right now; that would be
     // a better selector once it's fixed.
 
     $uses = $root->selectDescendantsOfType('n_USE_LIST');
     foreach ($uses as $use) {
       $this->raiseLintAtNode(
         $use,
         self::LINT_PHP_COMPATIBILITY,
         "This codebase targets PHP {$this->version}, but namespaces were not ".
         "introduced until PHP 5.3.");
     }
 
     $statics = $root->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
     foreach ($statics as $static) {
       $name = $static->getChildByIndex(0);
       if ($name->getTypeName() != 'n_CLASS_NAME') {
         continue;
       }
       if ($name->getConcreteString() == 'static') {
         $this->raiseLintAtNode(
           $name,
           self::LINT_PHP_COMPATIBILITY,
           "This codebase targets PHP {$this->version}, but `static::` was not ".
           "introduced until PHP 5.3.");
       }
     }
 
     $ternaries = $root->selectDescendantsOfType('n_TERNARY_EXPRESSION');
     foreach ($ternaries as $ternary) {
       $yes = $ternary->getChildByIndex(1);
       if ($yes->getTypeName() == 'n_EMPTY') {
         $this->raiseLintAtNode(
           $ternary,
           self::LINT_PHP_COMPATIBILITY,
           "This codebase targets PHP {$this->version}, but short ternary was ".
           "not introduced until PHP 5.3.");
       }
     }
 
     $heredocs = $root->selectDescendantsOfType('n_HEREDOC');
     foreach ($heredocs as $heredoc) {
       if (preg_match('/^<<<[\'"]/', $heredoc->getConcreteString())) {
         $this->raiseLintAtNode(
           $heredoc,
           self::LINT_PHP_COMPATIBILITY,
           "This codebase targets PHP {$this->version}, but nowdoc was not ".
           "introduced until PHP 5.3.");
       }
     }
   }
 
   private function lintPHP54Features(XHPASTNode $root) {
     $indexes = $root->selectDescendantsOfType('n_INDEX_ACCESS');
     foreach ($indexes as $index) {
       $left = $index->getChildByIndex(0);
       switch ($left->getTypeName()) {
         case 'n_FUNCTION_CALL':
         case 'n_METHOD_CALL':
           $this->raiseLintAtNode(
             $index->getChildByIndex(1),
             self::LINT_PHP_COMPATIBILITY,
             'The f()[...] syntax was not introduced until PHP 5.4, but this '.
             'codebase targets an earlier version of PHP. You can rewrite '.
             'this expression using idx().');
           break;
       }
     }
   }
 
   private function lintImplicitFallthrough(XHPASTNode $root) {
     $hook_obj = null;
     $working_copy = $this->getEngine()->getWorkingCopy();
     if ($working_copy) {
       $hook_class = $this->switchhook
         ? $this->switchhook
         : $this->getDeprecatedConfiguration('lint.xhpast.switchhook');
       if ($hook_class) {
         $hook_obj = newv($hook_class, array());
         assert_instances_of(array($hook_obj), 'ArcanistXHPASTLintSwitchHook');
       }
     }
 
     $switches = $root->selectDescendantsOfType('n_SWITCH');
     foreach ($switches as $switch) {
       $blocks = array();
 
       $cases = $switch->selectDescendantsOfType('n_CASE');
       foreach ($cases as $case) {
         $blocks[] = $case;
       }
 
       $defaults = $switch->selectDescendantsOfType('n_DEFAULT');
       foreach ($defaults as $default) {
         $blocks[] = $default;
       }
 
 
       foreach ($blocks as $key => $block) {
         // Collect all the tokens in this block which aren't at top level.
         // We want to ignore "break", and "continue" in these blocks.
         $lower_level = $block->selectDescendantsOfType('n_WHILE');
         $lower_level->add($block->selectDescendantsOfType('n_DO_WHILE'));
         $lower_level->add($block->selectDescendantsOfType('n_FOR'));
         $lower_level->add($block->selectDescendantsOfType('n_FOREACH'));
         $lower_level->add($block->selectDescendantsOfType('n_SWITCH'));
         $lower_level_tokens = array();
         foreach ($lower_level as $lower_level_block) {
           $lower_level_tokens += $lower_level_block->getTokens();
         }
 
         // Collect all the tokens in this block which aren't in this scope
         // (because they're inside class, function or interface declarations).
         // We want to ignore all of these tokens.
         $decls = $block->selectDescendantsOfType('n_FUNCTION_DECLARATION');
         $decls->add($block->selectDescendantsOfType('n_CLASS_DECLARATION'));
         // For completeness; these can't actually have anything.
         $decls->add($block->selectDescendantsOfType('n_INTERFACE_DECLARATION'));
         $different_scope_tokens = array();
         foreach ($decls as $decl) {
           $different_scope_tokens += $decl->getTokens();
         }
 
         $lower_level_tokens += $different_scope_tokens;
 
         // Get all the trailing nonsemantic tokens, since we need to look for
         // "fallthrough" comments past the end of the semantic block.
 
         $tokens = $block->getTokens();
         $last = end($tokens);
         while ($last && $last = $last->getNextToken()) {
           if ($last->isSemantic()) {
             break;
           }
           $tokens[$last->getTokenID()] = $last;
         }
 
         $blocks[$key] = array(
           $tokens,
           $lower_level_tokens,
           $different_scope_tokens,
         );
       }
 
       foreach ($blocks as $token_lists) {
         list(
           $tokens,
           $lower_level_tokens,
           $different_scope_tokens) = $token_lists;
 
         // Test each block (case or default statement) to see if it's OK. It's
         // OK if:
         //
         //  - it is empty; or
         //  - it ends in break, return, throw, continue or exit at top level; or
         //  - it has a comment with "fallthrough" in its text.
 
         // Empty blocks are OK, so we start this at `true` and only set it to
         // false if we find a statement.
         $block_ok = true;
 
         // Keeps track of whether the current statement is one that validates
         // the block (break, return, throw, continue) or something else.
         $statement_ok = false;
 
         foreach ($tokens as $token_id => $token) {
           if (!$token->isSemantic()) {
             // Liberally match "fall" in the comment text so that comments like
             // "fallthru", "fall through", "fallthrough", etc., are accepted.
             if (preg_match('/fall/i', $token->getValue())) {
               $block_ok = true;
               break;
             }
             continue;
           }
 
           $tok_type = $token->getTypeName();
 
           if ($tok_type == 'T_FUNCTION' ||
               $tok_type == 'T_CLASS' ||
               $tok_type == 'T_INTERFACE') {
             // These aren't statements, but mark the block as nonempty anyway.
             $block_ok = false;
             continue;
           }
 
           if ($tok_type == ';') {
             if ($statement_ok) {
               $statment_ok = false;
             } else {
               $block_ok = false;
             }
             continue;
           }
 
           if ($tok_type == 'T_BREAK'    ||
               $tok_type == 'T_CONTINUE') {
             if (empty($lower_level_tokens[$token_id])) {
               $statement_ok = true;
               $block_ok = true;
             }
             continue;
           }
 
           if ($tok_type == 'T_RETURN'   ||
               $tok_type == 'T_THROW'    ||
               $tok_type == 'T_EXIT'     ||
               ($hook_obj && $hook_obj->checkSwitchToken($token))) {
             if (empty($different_scope_tokens[$token_id])) {
               $statement_ok = true;
               $block_ok = true;
             }
             continue;
           }
         }
 
         if (!$block_ok) {
           $this->raiseLintAtToken(
             head($tokens),
             self::LINT_IMPLICIT_FALLTHROUGH,
             "This 'case' or 'default' has a nonempty block which does not ".
             "end with 'break', 'continue', 'return', 'throw' or 'exit'. Did ".
             "you forget to add one of those? If you intend to fall through, ".
             "add a '// fallthrough' comment to silence this warning.");
         }
       }
     }
   }
 
   private function lintBraceFormatting(XHPASTNode $root) {
     foreach ($root->selectDescendantsOfType('n_STATEMENT_LIST') as $list) {
       $tokens = $list->getTokens();
       if (!$tokens || head($tokens)->getValue() != '{') {
         continue;
       }
       list($before, $after) = $list->getSurroundingNonsemanticTokens();
       if (!$before) {
         $first = head($tokens);
 
         // Only insert the space if we're after a closing parenthesis. If
         // we're in a construct like "else{}", other rules will insert space
         // after the 'else' correctly.
         $prev = $first->getPrevToken();
         if (!$prev || $prev->getValue() != ')') {
           continue;
         }
 
         $this->raiseLintAtToken(
           $first,
           self::LINT_BRACE_FORMATTING,
           'Put opening braces on the same line as control statements and '.
           'declarations, with a single space before them.',
           ' '.$first->getValue());
       } else if (count($before) == 1) {
         $before = reset($before);
         if ($before->getValue() != ' ') {
           $this->raiseLintAtToken(
             $before,
             self::LINT_BRACE_FORMATTING,
             'Put opening braces on the same line as control statements and '.
             'declarations, with a single space before them.',
             ' ');
         }
       }
     }
   }
 
   private function lintTautologicalExpressions(XHPASTNode $root) {
     $expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
 
     static $operators = array(
       '-'   => true,
       '/'   => true,
       '-='  => true,
       '/='  => true,
       '<='  => true,
       '<'   => true,
       '=='  => true,
       '===' => true,
       '!='  => true,
       '!==' => true,
       '>='  => true,
       '>'   => true,
     );
 
     static $logical = array(
       '||'  => true,
       '&&'  => true,
     );
 
     foreach ($expressions as $expr) {
       $operator = $expr->getChildByIndex(1)->getConcreteString();
       if (!empty($operators[$operator])) {
         $left = $expr->getChildByIndex(0)->getSemanticString();
         $right = $expr->getChildByIndex(2)->getSemanticString();
 
         if ($left == $right) {
           $this->raiseLintAtNode(
             $expr,
             self::LINT_TAUTOLOGICAL_EXPRESSION,
             'Both sides of this expression are identical, so it always '.
             'evaluates to a constant.');
         }
       }
 
       if (!empty($logical[$operator])) {
         $left = $expr->getChildByIndex(0)->getSemanticString();
         $right = $expr->getChildByIndex(2)->getSemanticString();
 
         // NOTE: These will be null to indicate "could not evaluate".
         $left = $this->evaluateStaticBoolean($left);
         $right = $this->evaluateStaticBoolean($right);
 
         if (($operator == '||' && ($left === true || $right === true)) ||
             ($operator == '&&' && ($left === false || $right === false))) {
           $this->raiseLintAtNode(
             $expr,
             self::LINT_TAUTOLOGICAL_EXPRESSION,
             'The logical value of this expression is static. Did you forget '.
             'to remove some debugging code?');
         }
       }
     }
   }
 
   /**
    * Statically evaluate a boolean value from an XHP tree.
    *
    * TODO: Improve this and move it to XHPAST proper?
    *
    * @param  string The "semantic string" of a single value.
    * @return mixed  ##true## or ##false## if the value could be evaluated
    *                statically; ##null## if static evaluation was not possible.
    */
   private function evaluateStaticBoolean($string) {
     switch (strtolower($string)) {
       case '0':
       case 'null':
       case 'false':
         return false;
       case '1':
       case 'true':
         return true;
     }
     return null;
   }
 
 
   protected function lintCommentSpaces(XHPASTNode $root) {
     foreach ($root->selectTokensOfType('T_COMMENT') as $comment) {
       $value = $comment->getValue();
       if ($value[0] != '#') {
         $match = null;
         if (preg_match('@^(/[/*]+)[^/*\s]@', $value, $match)) {
           $this->raiseLintAtOffset(
             $comment->getOffset(),
             self::LINT_COMMENT_SPACING,
             'Put space after comment start.',
             $match[1],
             $match[1].' ');
         }
       }
     }
   }
 
 
   protected function lintHashComments(XHPASTNode $root) {
     foreach ($root->selectTokensOfType('T_COMMENT') as $comment) {
       $value = $comment->getValue();
       if ($value[0] != '#') {
         continue;
       }
 
       $this->raiseLintAtOffset(
         $comment->getOffset(),
         self::LINT_COMMENT_STYLE,
         'Use "//" single-line comments, not "#".',
         '#',
         (preg_match('/^#\S/', $value) ? '// ' : '//'));
     }
   }
 
   /**
    * Find cases where loops get nested inside each other but use the same
    * iterator variable. For example:
    *
    *  COUNTEREXAMPLE
    *  foreach ($list as $thing) {
    *    foreach ($stuff as $thing) { // <-- Raises an error for reuse of $thing
    *      // ...
    *    }
    *  }
    *
    */
   private function lintReusedIterators(XHPASTNode $root) {
     $used_vars = array();
 
     $for_loops = $root->selectDescendantsOfType('n_FOR');
     foreach ($for_loops as $for_loop) {
       $var_map = array();
 
       // Find all the variables that are assigned to in the for() expression.
       $for_expr = $for_loop->getChildOfType(0, 'n_FOR_EXPRESSION');
       $bin_exprs = $for_expr->selectDescendantsOfType('n_BINARY_EXPRESSION');
       foreach ($bin_exprs as $bin_expr) {
         if ($bin_expr->getChildByIndex(1)->getConcreteString() == '=') {
           $var = $bin_expr->getChildByIndex(0);
           $var_map[$var->getConcreteString()] = $var;
         }
       }
 
       $used_vars[$for_loop->getID()] = $var_map;
     }
 
     $foreach_loops = $root->selectDescendantsOfType('n_FOREACH');
     foreach ($foreach_loops as $foreach_loop) {
       $var_map = array();
 
       $foreach_expr = $foreach_loop->getChildOftype(0, 'n_FOREACH_EXPRESSION');
 
       // We might use one or two vars, i.e. "foreach ($x as $y => $z)" or
       // "foreach ($x as $y)".
       $possible_used_vars = array(
         $foreach_expr->getChildByIndex(1),
         $foreach_expr->getChildByIndex(2),
       );
       foreach ($possible_used_vars as $var) {
         if ($var->getTypeName() == 'n_EMPTY') {
           continue;
         }
         $name = $var->getConcreteString();
         $name = trim($name, '&'); // Get rid of ref silliness.
         $var_map[$name] = $var;
       }
 
       $used_vars[$foreach_loop->getID()] = $var_map;
     }
 
     $all_loops = $for_loops->add($foreach_loops);
     foreach ($all_loops as $loop) {
       $child_for_loops = $loop->selectDescendantsOfType('n_FOR');
       $child_foreach_loops = $loop->selectDescendantsOfType('n_FOREACH');
       $child_loops = $child_for_loops->add($child_foreach_loops);
 
       $outer_vars = $used_vars[$loop->getID()];
       foreach ($child_loops as $inner_loop) {
         $inner_vars = $used_vars[$inner_loop->getID()];
         $shared = array_intersect_key($outer_vars, $inner_vars);
         if ($shared) {
           $shared_desc = implode(', ', array_keys($shared));
           $message = $this->raiseLintAtNode(
             $inner_loop->getChildByIndex(0),
             self::LINT_REUSED_ITERATORS,
             "This loop reuses iterator variables ({$shared_desc}) from an ".
             "outer loop. You might be clobbering the outer iterator. Change ".
             "the inner loop to use a different iterator name.");
 
           $locations = array();
           foreach ($shared as $var) {
             $locations[] = $this->getOtherLocation($var->getOffset());
           }
           $message->setOtherLocations($locations);
         }
       }
     }
   }
 
   /**
    * Find cases where a foreach loop is being iterated using a variable
    * reference and the same variable is used outside of the loop without
    * calling unset() or reassigning the variable to another variable
    * reference.
    *
    *  COUNTEREXAMPLE
    *  foreach ($ar as &$a) {
    *    // ...
    *  }
    *  $a = 1; // <-- Raises an error for using $a
    *
    */
   protected function lintReusedIteratorReferences(XHPASTNode $root) {
 
     $fdefs = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
     $mdefs = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
     $defs = $fdefs->add($mdefs);
 
     foreach ($defs as $def) {
 
       $body = $def->getChildByIndex(5);
       if ($body->getTypeName() == 'n_EMPTY') {
         // Abstract method declaration.
         continue;
       }
 
       $exclude = array();
 
       // Exclude uses of variables, unsets, and foreach loops
       // within closures - they are checked on their own
       $func_defs = $body->selectDescendantsOfType('n_FUNCTION_DECLARATION');
       foreach ($func_defs as $func_def) {
         $vars = $func_def->selectDescendantsOfType('n_VARIABLE');
         foreach ($vars as $var) {
           $exclude[$var->getID()] = true;
         }
 
         $unset_lists = $func_def->selectDescendantsOfType('n_UNSET_LIST');
         foreach ($unset_lists as $unset_list) {
           $exclude[$unset_list->getID()] = true;
         }
 
         $foreaches = $func_def->selectDescendantsOfType('n_FOREACH');
         foreach ($foreaches as $foreach) {
           $exclude[$foreach->getID()] = true;
         }
       }
 
       // Find all variables that are unset within the scope
       $unset_vars = array();
       $unset_lists = $body->selectDescendantsOfType('n_UNSET_LIST');
       foreach ($unset_lists as $unset_list) {
         if (isset($exclude[$unset_list->getID()])) {
           continue;
         }
 
         $unset_list_vars = $unset_list->selectDescendantsOfType('n_VARIABLE');
         foreach ($unset_list_vars as $var) {
           $concrete = $this->getConcreteVariableString($var);
           $unset_vars[$concrete][] = $var->getOffset();
           $exclude[$var->getID()] = true;
         }
       }
 
       // Find all reference variables in foreach expressions
       $reference_vars = array();
       $foreaches = $body->selectDescendantsOfType('n_FOREACH');
       foreach ($foreaches as $foreach) {
         if (isset($exclude[$foreach->getID()])) {
           continue;
         }
 
         $foreach_expr = $foreach->getChildOfType(0, 'n_FOREACH_EXPRESSION');
         $var = $foreach_expr->getChildByIndex(2);
         if ($var->getTypeName() != 'n_VARIABLE_REFERENCE') {
           continue;
         }
 
         $reference = $var->getChildByIndex(0);
         if ($reference->getTypeName() != 'n_VARIABLE') {
           continue;
         }
 
         $reference_name = $this->getConcreteVariableString($reference);
         $reference_vars[$reference_name][] = $reference->getOffset();
         $exclude[$reference->getID()] = true;
 
         // Exclude uses of the reference variable within the foreach loop
         $foreach_vars = $foreach->selectDescendantsOfType('n_VARIABLE');
         foreach ($foreach_vars as $var) {
           $name = $this->getConcreteVariableString($var);
           if ($name == $reference_name) {
             $exclude[$var->getID()] = true;
           }
         }
       }
 
       // Allow usage if the reference variable is assigned to another
       // reference variable
       $binary = $body->selectDescendantsOfType('n_BINARY_EXPRESSION');
       foreach ($binary as $expr) {
         if ($expr->getChildByIndex(1)->getConcreteString() != '=') {
           continue;
         }
         $lval = $expr->getChildByIndex(0);
         if ($lval->getTypeName() != 'n_VARIABLE') {
           continue;
         }
         $rval = $expr->getChildByIndex(2);
         if ($rval->getTypeName() != 'n_VARIABLE_REFERENCE') {
           continue;
         }
 
         // Counts as unsetting a variable
         $concrete = $this->getConcreteVariableString($lval);
         $unset_vars[$concrete][] = $lval->getOffset();
         $exclude[$lval->getID()] = true;
       }
 
       $all_vars = array();
       $all = $body->selectDescendantsOfType('n_VARIABLE');
       foreach ($all as $var) {
         if (isset($exclude[$var->getID()])) {
           continue;
         }
 
         $name = $this->getConcreteVariableString($var);
 
         if (!isset($reference_vars[$name])) {
           continue;
         }
 
         // Find the closest reference offset to this variable
         $reference_offset = null;
         foreach ($reference_vars[$name] as $offset) {
           if ($offset < $var->getOffset()) {
             $reference_offset = $offset;
           } else {
             break;
           }
         }
         if (!$reference_offset) {
           continue;
         }
 
         // Check if an unset exists between reference and usage of this
         // variable
         $warn = true;
         if (isset($unset_vars[$name])) {
           foreach ($unset_vars[$name] as $unset_offset) {
             if ($unset_offset > $reference_offset &&
                 $unset_offset < $var->getOffset()) {
                 $warn = false;
                 break;
             }
           }
         }
         if ($warn) {
           $this->raiseLintAtNode(
             $var,
             self::LINT_REUSED_ITERATOR_REFERENCE,
             'This variable was used already as a by-reference iterator '.
             'variable. Such variables survive outside the foreach loop, '.
             'do not reuse.');
         }
       }
 
     }
   }
 
   protected function lintVariableVariables(XHPASTNode $root) {
     $vvars = $root->selectDescendantsOfType('n_VARIABLE_VARIABLE');
     foreach ($vvars as $vvar) {
       $this->raiseLintAtNode(
         $vvar,
         self::LINT_VARIABLE_VARIABLE,
         'Rewrite this code to use an array. Variable variables are unclear '.
         'and hinder static analysis.');
     }
   }
 
   private function lintUndeclaredVariables(XHPASTNode $root) {
     // These things declare variables in a function:
     //    Explicit parameters
     //    Assignment
     //    Assignment via list()
     //    Static
     //    Global
     //    Lexical vars
     //    Builtins ($this)
     //    foreach()
     //    catch
     //
     // These things make lexical scope unknowable:
     //    Use of extract()
     //    Assignment to variable variables ($$x)
     //    Global with variable variables
     //
     // These things don't count as "using" a variable:
     //    isset()
     //    empty()
     //    Static class variables
     //
     // The general approach here is to find each function/method declaration,
     // then:
     //
     //  1. Identify all the variable declarations, and where they first occur
     //     in the function/method declaration.
     //  2. Identify all the uses that don't really count (as above).
     //  3. Everything else must be a use of a variable.
     //  4. For each variable, check if any uses occur before the declaration
     //     and warn about them.
     //
     // We also keep track of where lexical scope becomes unknowable (e.g.,
     // because the function calls extract() or uses dynamic variables,
     // preventing us from keeping track of which variables are defined) so we
     // can stop issuing warnings after that.
     //
     // TODO: Support functions defined inside other functions which is commonly
     // used with anonymous functions.
 
     $fdefs = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
     $mdefs = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
     $defs = $fdefs->add($mdefs);
 
     foreach ($defs as $def) {
 
       // We keep track of the first offset where scope becomes unknowable, and
       // silence any warnings after that. Default it to INT_MAX so we can min()
       // it later to keep track of the first problem we encounter.
       $scope_destroyed_at = PHP_INT_MAX;
 
       $declarations = array(
         '$this'     => 0,
       ) + array_fill_keys($this->getSuperGlobalNames(), 0);
       $declaration_tokens = array();
       $exclude_tokens = array();
       $vars = array();
 
       // First up, find all the different kinds of declarations, as explained
       // above. Put the tokens into the $vars array.
 
       $param_list = $def->getChildOfType(3, 'n_DECLARATION_PARAMETER_LIST');
       $param_vars = $param_list->selectDescendantsOfType('n_VARIABLE');
       foreach ($param_vars as $var) {
         $vars[] = $var;
       }
 
       // This is PHP5.3 closure syntax: function () use ($x) {};
       $lexical_vars = $def
         ->getChildByIndex(4)
         ->selectDescendantsOfType('n_VARIABLE');
       foreach ($lexical_vars as $var) {
         $vars[] = $var;
       }
 
       $body = $def->getChildByIndex(5);
       if ($body->getTypeName() == 'n_EMPTY') {
         // Abstract method declaration.
         continue;
       }
 
       $static_vars = $body
         ->selectDescendantsOfType('n_STATIC_DECLARATION')
         ->selectDescendantsOfType('n_VARIABLE');
       foreach ($static_vars as $var) {
         $vars[] = $var;
       }
 
 
       $global_vars = $body
         ->selectDescendantsOfType('n_GLOBAL_DECLARATION_LIST');
       foreach ($global_vars as $var_list) {
         foreach ($var_list->getChildren() as $var) {
           if ($var->getTypeName() == 'n_VARIABLE') {
             $vars[] = $var;
           } else {
             // Dynamic global variable, i.e. "global $$x;".
             $scope_destroyed_at = min($scope_destroyed_at, $var->getOffset());
             // An error is raised elsewhere, no need to raise here.
           }
         }
       }
 
       // Include "catch (Exception $ex)", but not variables in the body of the
       // catch block.
       $catches = $body->selectDescendantsOfType('n_CATCH');
       foreach ($catches as $catch) {
         $vars[] = $catch->getChildOfType(1, 'n_VARIABLE');
       }
 
       $binary = $body->selectDescendantsOfType('n_BINARY_EXPRESSION');
       foreach ($binary as $expr) {
         if ($expr->getChildByIndex(1)->getConcreteString() != '=') {
           continue;
         }
         $lval = $expr->getChildByIndex(0);
         if ($lval->getTypeName() == 'n_VARIABLE') {
           $vars[] = $lval;
         } else if ($lval->getTypeName() == 'n_LIST') {
           // Recursivey grab everything out of list(), since the grammar
           // permits list() to be nested. Also note that list() is ONLY valid
           // as an lval assignments, so we could safely lift this out of the
           // n_BINARY_EXPRESSION branch.
           $assign_vars = $lval->selectDescendantsOfType('n_VARIABLE');
           foreach ($assign_vars as $var) {
             $vars[] = $var;
           }
         }
 
         if ($lval->getTypeName() == 'n_VARIABLE_VARIABLE') {
           $scope_destroyed_at = min($scope_destroyed_at, $lval->getOffset());
           // No need to raise here since we raise an error elsewhere.
         }
       }
 
       $calls = $body->selectDescendantsOfType('n_FUNCTION_CALL');
       foreach ($calls as $call) {
         $name = strtolower($call->getChildByIndex(0)->getConcreteString());
 
         if ($name == 'empty' || $name == 'isset') {
           $params = $call
             ->getChildOfType(1, 'n_CALL_PARAMETER_LIST')
             ->selectDescendantsOfType('n_VARIABLE');
           foreach ($params as $var) {
             $exclude_tokens[$var->getID()] = true;
           }
           continue;
         }
         if ($name != 'extract') {
           continue;
         }
         $scope_destroyed_at = min($scope_destroyed_at, $call->getOffset());
         $this->raiseLintAtNode(
           $call,
           self::LINT_EXTRACT_USE,
           'Avoid extract(). It is confusing and hinders static analysis.');
       }
 
       // Now we have every declaration except foreach(), handled below. Build
       // two maps, one which just keeps track of which tokens are part of
       // declarations ($declaration_tokens) and one which has the first offset
       // where a variable is declared ($declarations).
 
       foreach ($vars as $var) {
         $concrete = $this->getConcreteVariableString($var);
         $declarations[$concrete] = min(
           idx($declarations, $concrete, PHP_INT_MAX),
           $var->getOffset());
         $declaration_tokens[$var->getID()] = true;
       }
 
       // Excluded tokens are ones we don't "count" as being used, described
       // above. Put them into $exclude_tokens.
 
       $class_statics = $body
         ->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
       $class_static_vars = $class_statics
         ->selectDescendantsOfType('n_VARIABLE');
       foreach ($class_static_vars as $var) {
         $exclude_tokens[$var->getID()] = true;
       }
 
 
       // Find all the variables in scope, and figure out where they are used.
       // We want to find foreach() iterators which are both declared before and
       // used after the foreach() loop.
 
       $uses = array();
 
       $all_vars = $body->selectDescendantsOfType('n_VARIABLE');
       $all = array();
 
       // NOTE: $all_vars is not a real array so we can't unset() it.
       foreach ($all_vars as $var) {
 
         // Be strict since it's easier; we don't let you reuse an iterator you
         // declared before a loop after the loop, even if you're just assigning
         // to it.
 
         $concrete = $this->getConcreteVariableString($var);
         $uses[$concrete][$var->getID()] = $var->getOffset();
 
         if (isset($declaration_tokens[$var->getID()])) {
           // We know this is part of a declaration, so it's fine.
           continue;
         }
         if (isset($exclude_tokens[$var->getID()])) {
           // We know this is part of isset() or similar, so it's fine.
           continue;
         }
 
         $all[$var->getOffset()] = $concrete;
       }
 
 
       // Do foreach() last, we want to handle implicit redeclaration of a
       // variable already in scope since this probably means we're ovewriting a
       // local.
 
       // NOTE: Processing foreach expressions in order allows programs which
       // reuse iterator variables in other foreach() loops -- this is fine. We
       // have a separate warning to prevent nested loops from reusing the same
       // iterators.
 
       $foreaches = $body->selectDescendantsOfType('n_FOREACH');
       $all_foreach_vars = array();
       foreach ($foreaches as $foreach) {
         $foreach_expr = $foreach->getChildOfType(0, 'n_FOREACH_EXPRESSION');
 
         $foreach_vars = array();
 
         // Determine the end of the foreach() loop.
         $foreach_tokens = $foreach->getTokens();
         $last_token = end($foreach_tokens);
         $foreach_end = $last_token->getOffset();
 
         $key_var = $foreach_expr->getChildByIndex(1);
         if ($key_var->getTypeName() == 'n_VARIABLE') {
           $foreach_vars[] = $key_var;
         }
 
         $value_var = $foreach_expr->getChildByIndex(2);
         if ($value_var->getTypeName() == 'n_VARIABLE') {
           $foreach_vars[] = $value_var;
         } else {
           // The root-level token may be a reference, as in:
           //    foreach ($a as $b => &$c) { ... }
           // Reach into the n_VARIABLE_REFERENCE node to grab the n_VARIABLE
           // node.
           $var = $value_var->getChildByIndex(0);
           if ($var->getTypeName() == 'n_VARIABLE_VARIABLE') {
             $var = $var->getChildByIndex(0);
           }
           $foreach_vars[] = $var;
         }
 
         // Remove all uses of the iterators inside of the foreach() loop from
         // the $uses map.
 
         foreach ($foreach_vars as $var) {
           $concrete = $this->getConcreteVariableString($var);
           $offset = $var->getOffset();
 
           foreach ($uses[$concrete] as $id => $use_offset) {
             if (($use_offset >= $offset) && ($use_offset < $foreach_end)) {
               unset($uses[$concrete][$id]);
             }
           }
 
           $all_foreach_vars[] = $var;
         }
       }
 
       foreach ($all_foreach_vars as $var) {
         $concrete = $this->getConcreteVariableString($var);
         $offset = $var->getOffset();
 
         // If a variable was declared before a foreach() and is used after
         // it, raise a message.
 
         if (isset($declarations[$concrete])) {
           if ($declarations[$concrete] < $offset) {
             if (!empty($uses[$concrete]) &&
                 max($uses[$concrete]) > $offset) {
               $message = $this->raiseLintAtNode(
                 $var,
                 self::LINT_REUSED_AS_ITERATOR,
                 'This iterator variable is a previously declared local '.
                 'variable. To avoid overwriting locals, do not reuse them '.
                 'as iterator variables.');
               $message->setOtherLocations(array(
                 $this->getOtherLocation($declarations[$concrete]),
                 $this->getOtherLocation(max($uses[$concrete])),
               ));
             }
           }
         }
 
         // This is a declaration, exclude it from the "declare variables prior
         // to use" check below.
         unset($all[$var->getOffset()]);
 
         $vars[] = $var;
       }
 
       // Now rebuild declarations to include foreach().
 
       foreach ($vars as $var) {
         $concrete = $this->getConcreteVariableString($var);
         $declarations[$concrete] = min(
           idx($declarations, $concrete, PHP_INT_MAX),
           $var->getOffset());
         $declaration_tokens[$var->getID()] = true;
       }
 
       foreach (array('n_STRING_SCALAR', 'n_HEREDOC') as $type) {
         foreach ($body->selectDescendantsOfType($type) as $string) {
           foreach ($string->getStringVariables() as $offset => $var) {
             $all[$string->getOffset() + $offset - 1] = '$'.$var;
           }
         }
       }
 
       // Issue a warning for every variable token, unless it appears in a
       // declaration, we know about a prior declaration, we have explicitly
       // exlcuded it, or scope has been made unknowable before it appears.
 
       $issued_warnings = array();
       foreach ($all as $offset => $concrete) {
         if ($offset >= $scope_destroyed_at) {
           // This appears after an extract() or $$var so we have no idea
           // whether it's legitimate or not. We raised a harshly-worded warning
           // when scope was made unknowable, so just ignore anything we can't
           // figure out.
           continue;
         }
         if ($offset >= idx($declarations, $concrete, PHP_INT_MAX)) {
           // The use appears after the variable is declared, so it's fine.
           continue;
         }
         if (!empty($issued_warnings[$concrete])) {
           // We've already issued a warning for this variable so we don't need
           // to issue another one.
           continue;
         }
         $this->raiseLintAtOffset(
           $offset,
           self::LINT_UNDECLARED_VARIABLE,
           'Declare variables prior to use (even if you are passing them '.
           'as reference parameters). You may have misspelled this '.
           'variable name.',
           $concrete);
         $issued_warnings[$concrete] = true;
       }
     }
   }
 
   private function getConcreteVariableString(XHPASTNode $var) {
     $concrete = $var->getConcreteString();
     // Strip off curly braces as in $obj->{$property}.
     $concrete = trim($concrete, '{}');
     return $concrete;
   }
 
   private function lintPHPTagUse(XHPASTNode $root) {
     $tokens = $root->getTokens();
     foreach ($tokens as $token) {
       if ($token->getTypeName() == 'T_OPEN_TAG') {
         if (trim($token->getValue()) == '<?') {
           $this->raiseLintAtToken(
             $token,
             self::LINT_PHP_SHORT_TAG,
             'Use the full form of the PHP open tag, "<?php".',
             "<?php\n");
         }
         break;
       } else if ($token->getTypeName() == 'T_OPEN_TAG_WITH_ECHO') {
         $this->raiseLintAtToken(
           $token,
           self::LINT_PHP_ECHO_TAG,
           'Avoid the PHP echo short form, "<?=".');
         break;
       } else {
         if (!preg_match('/^#!/', $token->getValue())) {
           $this->raiseLintAtToken(
             $token,
             self::LINT_PHP_OPEN_TAG,
             'PHP files should start with "<?php", which may be preceded by '.
             'a "#!" line for scripts.');
         }
         break;
       }
     }
 
     foreach ($root->selectTokensOfType('T_CLOSE_TAG') as $token) {
       $this->raiseLintAtToken(
         $token,
         self::LINT_PHP_CLOSE_TAG,
         'Do not use the PHP closing tag, "?>".');
     }
   }
 
   private function lintNamingConventions(XHPASTNode $root) {
     // We're going to build up a list of <type, name, token, error> tuples
     // and then try to instantiate a hook class which has the opportunity to
     // override us.
     $names = array();
 
     $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
     foreach ($classes as $class) {
       $name_token = $class->getChildByIndex(1);
       $name_string = $name_token->getConcreteString();
 
       $names[] = array(
         'class',
         $name_string,
         $name_token,
         ArcanistXHPASTLintNamingHook::isUpperCamelCase($name_string)
           ? null
           : 'Follow naming conventions: classes should be named using '.
             'UpperCamelCase.',
       );
     }
 
     $ifaces = $root->selectDescendantsOfType('n_INTERFACE_DECLARATION');
     foreach ($ifaces as $iface) {
       $name_token = $iface->getChildByIndex(1);
       $name_string = $name_token->getConcreteString();
       $names[] = array(
         'interface',
         $name_string,
         $name_token,
         ArcanistXHPASTLintNamingHook::isUpperCamelCase($name_string)
           ? null
           : 'Follow naming conventions: interfaces should be named using '.
             'UpperCamelCase.',
       );
     }
 
 
     $functions = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
     foreach ($functions as $function) {
       $name_token = $function->getChildByIndex(2);
       if ($name_token->getTypeName() == 'n_EMPTY') {
         // Unnamed closure.
         continue;
       }
       $name_string = $name_token->getConcreteString();
       $names[] = array(
         'function',
         $name_string,
         $name_token,
         ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores(
           ArcanistXHPASTLintNamingHook::stripPHPFunction($name_string))
           ? null
           : 'Follow naming conventions: functions should be named using '.
             'lowercase_with_underscores.',
       );
     }
 
 
     $methods = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
     foreach ($methods as $method) {
       $name_token = $method->getChildByIndex(2);
       $name_string = $name_token->getConcreteString();
       $names[] = array(
         'method',
         $name_string,
         $name_token,
         ArcanistXHPASTLintNamingHook::isLowerCamelCase(
           ArcanistXHPASTLintNamingHook::stripPHPFunction($name_string))
           ? null
           : 'Follow naming conventions: methods should be named using '.
             'lowerCamelCase.',
       );
     }
 
     $param_tokens = array();
 
     $params = $root->selectDescendantsOfType('n_DECLARATION_PARAMETER_LIST');
     foreach ($params as $param_list) {
       foreach ($param_list->getChildren() as $param) {
         $name_token = $param->getChildByIndex(1);
         if ($name_token->getTypeName() == 'n_VARIABLE_REFERENCE') {
           $name_token = $name_token->getChildOfType(0, 'n_VARIABLE');
         }
         $param_tokens[$name_token->getID()] = true;
         $name_string = $name_token->getConcreteString();
 
         $names[] = array(
           'parameter',
           $name_string,
           $name_token,
           ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores(
             ArcanistXHPASTLintNamingHook::stripPHPVariable($name_string))
             ? null
             : 'Follow naming conventions: parameters should be named using '.
               'lowercase_with_underscores.',
         );
       }
     }
 
 
     $constants = $root->selectDescendantsOfType(
       'n_CLASS_CONSTANT_DECLARATION_LIST');
     foreach ($constants as $constant_list) {
       foreach ($constant_list->getChildren() as $constant) {
         $name_token = $constant->getChildByIndex(0);
         $name_string = $name_token->getConcreteString();
         $names[] = array(
           'constant',
           $name_string,
           $name_token,
           ArcanistXHPASTLintNamingHook::isUppercaseWithUnderscores($name_string)
             ? null
             : 'Follow naming conventions: class constants should be named '.
               'using UPPERCASE_WITH_UNDERSCORES.',
         );
       }
     }
 
     $member_tokens = array();
 
     $props = $root->selectDescendantsOfType('n_CLASS_MEMBER_DECLARATION_LIST');
     foreach ($props as $prop_list) {
       foreach ($prop_list->getChildren() as $token_id => $prop) {
         if ($prop->getTypeName() == 'n_CLASS_MEMBER_MODIFIER_LIST') {
           continue;
         }
 
         $name_token = $prop->getChildByIndex(0);
         $member_tokens[$name_token->getID()] = true;
 
         $name_string = $name_token->getConcreteString();
         $names[] = array(
           'member',
           $name_string,
           $name_token,
           ArcanistXHPASTLintNamingHook::isLowerCamelCase(
             ArcanistXHPASTLintNamingHook::stripPHPVariable($name_string))
             ? null
             : 'Follow naming conventions: class properties should be named '.
               'using lowerCamelCase.',
         );
       }
     }
 
     $superglobal_map = array_fill_keys(
       $this->getSuperGlobalNames(),
       true);
 
 
     $fdefs = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
     $mdefs = $root->selectDescendantsOfType('n_METHOD_DECLARATION');
     $defs = $fdefs->add($mdefs);
 
     foreach ($defs as $def) {
       $globals = $def->selectDescendantsOfType('n_GLOBAL_DECLARATION_LIST');
       $globals = $globals->selectDescendantsOfType('n_VARIABLE');
 
       $globals_map = array();
       foreach ($globals as $global) {
         $global_string = $global->getConcreteString();
         $globals_map[$global_string] = true;
         $names[] = array(
           'user',
           $global_string,
           $global,
 
           // No advice for globals, but hooks have an option to provide some.
           null);
       }
 
       // Exclude access of static properties, since lint will be raised at
       // their declaration if they're invalid and they may not conform to
       // variable rules. This is slightly overbroad (includes the entire
       // rhs of a "Class::..." token) to cover cases like "Class:$x[0]". These
       // variables are simply made exempt from naming conventions.
       $exclude_tokens = array();
       $statics = $def->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
       foreach ($statics as $static) {
         $rhs = $static->getChildByIndex(1);
         $rhs_vars = $def->selectDescendantsOfType('n_VARIABLE');
         foreach ($rhs_vars as $var) {
           $exclude_tokens[$var->getID()] = true;
         }
       }
 
       $vars = $def->selectDescendantsOfType('n_VARIABLE');
       foreach ($vars as $token_id => $var) {
         if (isset($member_tokens[$token_id])) {
           continue;
         }
         if (isset($param_tokens[$token_id])) {
           continue;
         }
         if (isset($exclude_tokens[$token_id])) {
           continue;
         }
 
         $var_string = $var->getConcreteString();
 
         // Awkward artifact of "$o->{$x}".
         $var_string = trim($var_string, '{}');
 
         if (isset($superglobal_map[$var_string])) {
           continue;
         }
         if (isset($globals_map[$var_string])) {
           continue;
         }
 
         $names[] = array(
           'variable',
           $var_string,
           $var,
           ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores(
             ArcanistXHPASTLintNamingHook::stripPHPVariable($var_string))
               ? null
               : 'Follow naming conventions: variables should be named using '.
                 'lowercase_with_underscores.',
         );
       }
     }
 
     $engine = $this->getEngine();
     $working_copy = $engine->getWorkingCopy();
 
     if ($working_copy) {
       // If a naming hook is configured, give it a chance to override the
       // default results for all the symbol names.
       $hook_class = $this->naminghook
         ? $this->naminghook
         : $working_copy->getProjectConfig('lint.xhpast.naminghook');
       if ($hook_class) {
         $hook_obj = newv($hook_class, array());
         foreach ($names as $k => $name_attrs) {
           list($type, $name, $token, $default) = $name_attrs;
           $result = $hook_obj->lintSymbolName($type, $name, $default);
           $names[$k][3] = $result;
         }
       }
     }
 
     // Raise anything we're left with.
     foreach ($names as $k => $name_attrs) {
       list($type, $name, $token, $result) = $name_attrs;
       if ($result) {
         $this->raiseLintAtNode(
           $token,
           self::LINT_NAMING_CONVENTIONS,
           $result);
       }
     }
   }
 
   private function lintSurpriseConstructors(XHPASTNode $root) {
     $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
     foreach ($classes as $class) {
       $class_name = $class->getChildByIndex(1)->getConcreteString();
       $methods = $class->selectDescendantsOfType('n_METHOD_DECLARATION');
       foreach ($methods as $method) {
         $method_name_token = $method->getChildByIndex(2);
         $method_name = $method_name_token->getConcreteString();
         if (strtolower($class_name) == strtolower($method_name)) {
           $this->raiseLintAtNode(
             $method_name_token,
             self::LINT_IMPLICIT_CONSTRUCTOR,
             'Name constructors __construct() explicitly. This method is a '.
             'constructor because it has the same name as the class it is '.
             'defined in.');
         }
       }
     }
   }
 
   private function lintParenthesesShouldHugExpressions(XHPASTNode $root) {
     $calls = $root->selectDescendantsOfType('n_CALL_PARAMETER_LIST');
     $controls = $root->selectDescendantsOfType('n_CONTROL_CONDITION');
     $fors = $root->selectDescendantsOfType('n_FOR_EXPRESSION');
     $foreach = $root->selectDescendantsOfType('n_FOREACH_EXPRESSION');
     $decl = $root->selectDescendantsOfType('n_DECLARATION_PARAMETER_LIST');
 
     $all_paren_groups = $calls
       ->add($controls)
       ->add($fors)
       ->add($foreach)
       ->add($decl);
     foreach ($all_paren_groups as $group) {
       $tokens = $group->getTokens();
 
       $token_o = array_shift($tokens);
       $token_c = array_pop($tokens);
       if ($token_o->getTypeName() != '(') {
         throw new Exception('Expected open paren!');
       }
       if ($token_c->getTypeName() != ')') {
         throw new Exception('Expected close paren!');
       }
 
       $nonsem_o = $token_o->getNonsemanticTokensAfter();
       $nonsem_c = $token_c->getNonsemanticTokensBefore();
 
       if (!$nonsem_o) {
         continue;
       }
 
       $raise = array();
 
       $string_o = implode('', mpull($nonsem_o, 'getValue'));
       if (preg_match('/^[ ]+$/', $string_o)) {
         $raise[] = array($nonsem_o, $string_o);
       }
 
       if ($nonsem_o !== $nonsem_c) {
         $string_c = implode('', mpull($nonsem_c, 'getValue'));
         if (preg_match('/^[ ]+$/', $string_c)) {
           $raise[] = array($nonsem_c, $string_c);
         }
       }
 
       foreach ($raise as $warning) {
         list($tokens, $string) = $warning;
         $this->raiseLintAtOffset(
           reset($tokens)->getOffset(),
           self::LINT_PARENTHESES_SPACING,
           'Parentheses should hug their contents.',
           $string,
           '');
       }
     }
   }
 
   private function lintSpaceAfterControlStatementKeywords(XHPASTNode $root) {
     foreach ($root->getTokens() as $id => $token) {
       switch ($token->getTypeName()) {
         case 'T_IF':
         case 'T_ELSE':
         case 'T_FOR':
         case 'T_FOREACH':
         case 'T_WHILE':
         case 'T_DO':
         case 'T_SWITCH':
           $after = $token->getNonsemanticTokensAfter();
           if (empty($after)) {
             $this->raiseLintAtToken(
               $token,
               self::LINT_CONTROL_STATEMENT_SPACING,
               'Convention: put a space after control statements.',
               $token->getValue().' ');
           } else if (count($after) == 1) {
             $space = head($after);
 
             // If we have an else clause with braces, $space may not be
             // a single white space. e.g.,
             //
             //  if ($x)
             //    echo 'foo'
             //  else          // <- $space is not " " but "\n  ".
             //    echo 'bar'
             //
             // We just require it starts with either a whitespace or a newline.
             if ($token->getTypeName() == 'T_ELSE' ||
                 $token->getTypeName() == 'T_DO') {
               break;
             }
 
             if ($space->isAnyWhitespace() && $space->getValue() != ' ') {
               $this->raiseLintAtToken(
                 $space,
                 self::LINT_CONTROL_STATEMENT_SPACING,
                 'Convention: put a single space after control statements.',
                 ' ');
             }
           }
           break;
       }
     }
   }
 
   private function lintSpaceAroundBinaryOperators(XHPASTNode $root) {
     $expressions = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
     foreach ($expressions as $expression) {
       $operator = $expression->getChildByIndex(1);
       $operator_value = $operator->getConcreteString();
       list($before, $after) = $operator->getSurroundingNonsemanticTokens();
 
       $replace = null;
       if (empty($before) && empty($after)) {
         $replace = " {$operator_value} ";
       } else if (empty($before)) {
         $replace = " {$operator_value}";
       } else if (empty($after)) {
         $replace = "{$operator_value} ";
       }
 
       if ($replace !== null) {
         $this->raiseLintAtNode(
           $operator,
           self::LINT_BINARY_EXPRESSION_SPACING,
           'Convention: logical and arithmetic operators should be '.
           'surrounded by whitespace.',
           $replace);
       }
     }
 
     $tokens = $root->selectTokensOfType(',');
     foreach ($tokens as $token) {
       $next = $token->getNextToken();
       switch ($next->getTypeName()) {
         case ')':
         case 'T_WHITESPACE':
           break;
         default:
           $this->raiseLintAtToken(
             $token,
             self::LINT_BINARY_EXPRESSION_SPACING,
             'Convention: comma should be followed by space.',
             ', ');
           break;
       }
     }
 
     $tokens = $root->selectTokensOfType('T_DOUBLE_ARROW');
     foreach ($tokens as $token) {
       $prev = $token->getPrevToken();
       $next = $token->getNextToken();
 
       $prev_type = $prev->getTypeName();
       $next_type = $next->getTypeName();
 
       $prev_space = ($prev_type == 'T_WHITESPACE');
       $next_space = ($next_type == 'T_WHITESPACE');
 
       $replace = null;
       if (!$prev_space && !$next_space) {
         $replace = ' => ';
       } else if ($prev_space && !$next_space) {
         $replace = '=> ';
       } else if (!$prev_space && $next_space) {
         $replace = ' =>';
       }
 
       if ($replace !== null) {
         $this->raiseLintAtToken(
           $token,
           self::LINT_BINARY_EXPRESSION_SPACING,
           'Convention: double arrow should be surrounded by whitespace.',
           $replace);
       }
     }
 
     // TODO: Spacing around default parameter assignment in function/method
     // declarations (which is not n_BINARY_EXPRESSION).
   }
 
   private function lintSpaceAroundConcatenationOperators(XHPASTNode $root) {
     $tokens = $root->selectTokensOfType('.');
     foreach ($tokens as $token) {
       $prev = $token->getPrevToken();
       $next = $token->getNextToken();
 
       foreach (array('prev' => $prev, 'next' => $next) as $wtoken) {
         if ($wtoken->getTypeName() != 'T_WHITESPACE') {
           continue;
         }
 
         $value = $wtoken->getValue();
         if (strpos($value, "\n") !== false) {
           // If the whitespace has a newline, it's conventional.
           continue;
         }
 
         $next = $wtoken->getNextToken();
         if ($next && $next->getTypeName() == 'T_COMMENT') {
           continue;
         }
 
         $this->raiseLintAtToken(
           $wtoken,
           self::LINT_BINARY_EXPRESSION_SPACING,
           'Convention: no spaces around "." (string concatenation) operator.',
           '');
       }
     }
   }
 
   private function lintDynamicDefines(XHPASTNode $root) {
     $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
     foreach ($calls as $call) {
       $name = $call->getChildByIndex(0)->getConcreteString();
       if (strtolower($name) == 'define') {
         $parameter_list = $call->getChildOfType(1, 'n_CALL_PARAMETER_LIST');
         $defined = $parameter_list->getChildByIndex(0);
         if (!$defined->isStaticScalar()) {
           $this->raiseLintAtNode(
             $defined,
             self::LINT_DYNAMIC_DEFINE,
             'First argument to define() must be a string literal.');
         }
       }
     }
   }
 
   private function lintUseOfThisInStaticMethods(XHPASTNode $root) {
     $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
     foreach ($classes as $class) {
       $methods = $class->selectDescendantsOfType('n_METHOD_DECLARATION');
       foreach ($methods as $method) {
 
         $attributes = $method
           ->getChildByIndex(0, 'n_METHOD_MODIFIER_LIST')
           ->selectDescendantsOfType('n_STRING');
 
         $method_is_static = false;
         $method_is_abstract = false;
         foreach ($attributes as $attribute) {
           if (strtolower($attribute->getConcreteString()) == 'static') {
             $method_is_static = true;
           }
           if (strtolower($attribute->getConcreteString()) == 'abstract') {
             $method_is_abstract = true;
           }
         }
 
         if ($method_is_abstract) {
           continue;
         }
 
         if (!$method_is_static) {
           continue;
         }
 
         $body = $method->getChildOfType(5, 'n_STATEMENT_LIST');
 
         $variables = $body->selectDescendantsOfType('n_VARIABLE');
         foreach ($variables as $variable) {
           if ($method_is_static &&
               strtolower($variable->getConcreteString()) == '$this') {
             $this->raiseLintAtNode(
               $variable,
               self::LINT_STATIC_THIS,
               'You can not reference "$this" inside a static method.');
           }
         }
       }
     }
   }
 
   /**
    * preg_quote() takes two arguments, but the second one is optional because
-   * it is possible to use (), [] or {} as regular expression delimiters.  If
+   * it is possible to use (), [] or {} as regular expression delimiters. If
    * you don't pass a second argument, you're probably going to get something
    * wrong.
    */
   private function lintPregQuote(XHPASTNode $root) {
     $function_calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
     foreach ($function_calls as $call) {
       $name = $call->getChildByIndex(0)->getConcreteString();
       if (strtolower($name) === 'preg_quote') {
         $parameter_list = $call->getChildOfType(1, 'n_CALL_PARAMETER_LIST');
         if (count($parameter_list->getChildren()) !== 2) {
           $this->raiseLintAtNode(
             $call,
             self::LINT_PREG_QUOTE_MISUSE,
             'If you use pattern delimiters that require escaping (such as //, '.
             'but not ()) then you should pass two arguments to preg_quote(), '.
             'so that preg_quote() knows which delimiter to escape.');
         }
       }
     }
   }
 
   /**
    * Exit is parsed as an expression, but using it as such is almost always
    * wrong. That is, this is valid:
    *
    *    strtoupper(33 * exit - 6);
    *
    * When exit is used as an expression, it causes the program to terminate with
    * exit code 0. This is likely not what is intended; these statements have
    * different effects:
    *
    *    exit(-1);
    *    exit -1;
    *
    * The former exits with a failure code, the latter with a success code!
    */
   private function lintExitExpressions(XHPASTNode $root) {
     $unaries = $root->selectDescendantsOfType('n_UNARY_PREFIX_EXPRESSION');
     foreach ($unaries as $unary) {
       $operator = $unary->getChildByIndex(0)->getConcreteString();
       if (strtolower($operator) == 'exit') {
         if ($unary->getParentNode()->getTypeName() != 'n_STATEMENT') {
           $this->raiseLintAtNode(
             $unary,
             self::LINT_EXIT_EXPRESSION,
             'Use exit as a statement, not an expression.');
         }
       }
     }
   }
 
   private function lintArrayIndexWhitespace(XHPASTNode $root) {
     $indexes = $root->selectDescendantsOfType('n_INDEX_ACCESS');
     foreach ($indexes as $index) {
       $tokens = $index->getChildByIndex(0)->getTokens();
       $last = array_pop($tokens);
       $trailing = $last->getNonsemanticTokensAfter();
       $trailing_text = implode('', mpull($trailing, 'getValue'));
       if (preg_match('/^ +$/', $trailing_text)) {
         $this->raiseLintAtOffset(
           $last->getOffset() + strlen($last->getValue()),
           self::LINT_ARRAY_INDEX_SPACING,
           'Convention: no spaces before index access.',
           $trailing_text,
           '');
       }
     }
   }
 
   private function lintTODOComments(XHPASTNode $root) {
     $comments = $root->selectTokensOfType('T_COMMENT') +
                 $root->selectTokensOfType('T_DOC_COMMENT');
 
     foreach ($comments as $token) {
       $value = $token->getValue();
       if ($token->getTypeName() === 'T_DOC_COMMENT') {
         $regex = '/(TODO|@todo)/';
       } else {
         $regex = '/TODO/';
       }
 
       $matches = null;
       $preg = preg_match_all(
         $regex,
         $value,
         $matches,
         PREG_OFFSET_CAPTURE);
 
       foreach ($matches[0] as $match) {
         list($string, $offset) = $match;
         $this->raiseLintAtOffset(
           $token->getOffset() + $offset,
           self::LINT_TODO_COMMENT,
           'This comment has a TODO.',
           $string);
       }
     }
   }
 
   /**
    * Lint that if the file declares exactly one interface or class,
    * the name of the file matches the name of the class,
    * unless the classname is funky like an XHP element.
    */
   private function lintPrimaryDeclarationFilenameMatch(XHPASTNode $root) {
     $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
     $interfaces = $root->selectDescendantsOfType('n_INTERFACE_DECLARATION');
 
     if (count($classes) + count($interfaces) != 1) {
       return;
     }
 
     $declarations = count($classes) ? $classes : $interfaces;
     $declarations->rewind();
     $declaration = $declarations->current();
 
     $decl_name = $declaration->getChildByIndex(1);
     $decl_string = $decl_name->getConcreteString();
 
     // Exclude strangely named classes, e.g. XHP tags.
     if (!preg_match('/^\w+$/', $decl_string)) {
       return;
     }
 
     $rename = $decl_string.'.php';
 
     $path = $this->getActivePath();
     $filename = basename($path);
 
     if ($rename == $filename) {
       return;
     }
 
     $this->raiseLintAtNode(
       $decl_name,
       self::LINT_CLASS_FILENAME_MISMATCH,
       "The name of this file differs from the name of the class or interface ".
       "it declares. Rename the file to '{$rename}'.");
   }
 
   private function lintPlusOperatorOnStrings(XHPASTNode $root) {
     $binops = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
     foreach ($binops as $binop) {
       $op = $binop->getChildByIndex(1);
       if ($op->getConcreteString() != '+') {
         continue;
       }
 
       $left = $binop->getChildByIndex(0);
       $right = $binop->getChildByIndex(2);
       if (($left->getTypeName() == 'n_STRING_SCALAR') ||
           ($right->getTypeName() == 'n_STRING_SCALAR')) {
         $this->raiseLintAtNode(
           $binop,
           self::LINT_PLUS_OPERATOR_ON_STRINGS,
           "In PHP, '.' is the string concatenation operator, not '+'. This ".
           "expression uses '+' with a string literal as an operand.");
       }
     }
   }
 
   /**
    * Finds duplicate keys in array initializers, as in
-   * array(1 => 'anything', 1 => 'foo').  Since the first entry is ignored,
+   * array(1 => 'anything', 1 => 'foo'). Since the first entry is ignored,
    * this is almost certainly an error.
    */
   private function lintDuplicateKeysInArray(XHPASTNode $root) {
     $array_literals = $root->selectDescendantsOfType('n_ARRAY_LITERAL');
     foreach ($array_literals as $array_literal) {
       $nodes_by_key = array();
       $keys_warn = array();
       $list_node = $array_literal->getChildByIndex(0);
       foreach ($list_node->getChildren() as $array_entry) {
         $key_node = $array_entry->getChildByIndex(0);
 
         switch ($key_node->getTypeName()) {
           case 'n_STRING_SCALAR':
           case 'n_NUMERIC_SCALAR':
             // Scalars: array(1 => 'v1', '1' => 'v2');
             $key = 'scalar:'.(string)$key_node->evalStatic();
             break;
 
           case 'n_SYMBOL_NAME':
           case 'n_VARIABLE':
           case 'n_CLASS_STATIC_ACCESS':
             // Constants: array(CONST => 'v1', CONST => 'v2');
             // Variables: array($a => 'v1', $a => 'v2');
             // Class constants and vars: array(C::A => 'v1', C::A => 'v2');
             $key = $key_node->getTypeName().':'.$key_node->getConcreteString();
             break;
 
           default:
             $key = null;
             break;
         }
 
         if ($key !== null) {
           if (isset($nodes_by_key[$key])) {
             $keys_warn[$key] = true;
           }
           $nodes_by_key[$key][] = $key_node;
         }
       }
 
       foreach ($keys_warn as $key => $_) {
         $node = array_pop($nodes_by_key[$key]);
         $message = $this->raiseLintAtNode(
           $node,
           self::LINT_DUPLICATE_KEYS_IN_ARRAY,
           'Duplicate key in array initializer. PHP will ignore all '.
             'but the last entry.');
 
         $locations = array();
         foreach ($nodes_by_key[$key] as $node) {
           $locations[] = $this->getOtherLocation($node->getOffset());
         }
         $message->setOtherLocations($locations);
       }
     }
   }
 
   private function lintClosingCallParen(XHPASTNode $root) {
     $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
     $calls = $calls->add($root->selectDescendantsOfType('n_METHOD_CALL'));
 
     foreach ($calls as $call) {
       // If the last parameter of a call is a HEREDOC, don't apply this rule.
       $params = $call
         ->getChildOfType(1, 'n_CALL_PARAMETER_LIST')
         ->getChildren();
 
       if ($params) {
         $last_param = last($params);
         if ($last_param->getTypeName() == 'n_HEREDOC') {
           continue;
         }
       }
 
       $tokens = $call->getTokens();
       $last = array_pop($tokens);
 
       $trailing = $last->getNonsemanticTokensBefore();
       $trailing_text = implode('', mpull($trailing, 'getValue'));
       if (preg_match('/^\s+$/', $trailing_text)) {
         $this->raiseLintAtOffset(
           $last->getOffset() - strlen($trailing_text),
           self::LINT_CLOSING_CALL_PAREN,
           'Convention: no spaces before closing parenthesis in calls.',
           $trailing_text,
           '');
       }
     }
   }
 
   private function lintClosingDeclarationParen(XHPASTNode $root) {
     $decs = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
     $decs = $decs->add($root->selectDescendantsOfType('n_METHOD_DECLARATION'));
 
     foreach ($decs as $dec) {
       $params = $dec->getChildOfType(3, 'n_DECLARATION_PARAMETER_LIST');
       $tokens = $params->getTokens();
       $last = array_pop($tokens);
 
       $trailing = $last->getNonsemanticTokensBefore();
       $trailing_text = implode('', mpull($trailing, 'getValue'));
       if (preg_match('/^\s+$/', $trailing_text)) {
         $this->raiseLintAtOffset(
           $last->getOffset() - strlen($trailing_text),
           self::LINT_CLOSING_DECL_PAREN,
           'Convention: no spaces before closing parenthesis in function and '.
           'method declarations.',
           $trailing_text,
           '');
       }
     }
   }
 
   private function lintKeywordCasing(XHPASTNode $root) {
     $keywords = array();
 
     $symbols = $root->selectDescendantsOfType('n_SYMBOL_NAME');
     foreach ($symbols as $symbol) {
       $keywords[] = head($symbol->getTokens());
     }
 
     $arrays = $root->selectDescendantsOfType('n_ARRAY_LITERAL');
     foreach ($arrays as $array) {
       $keywords[] = head($array->getTokens());
     }
 
     $typehints = $root->selectDescendantsOfType('n_TYPE_NAME');
     foreach ($typehints as $typehint) {
       $keywords[] = head($typehint->getTokens());
     }
 
     $new_invocations = $root->selectDescendantsOfType('n_NEW');
     foreach ($new_invocations as $invocation) {
       $keywords[] = head($invocation->getTokens());
     }
 
     // NOTE: Although PHP generally allows arbitrary casing for all language
     // keywords, it's exceedingly rare for anyone to type, e.g., "CLASS" or
     // "cLaSs" in the wild. This list just attempts to cover unconventional
     // spellings which see some level of use, not all keywords exhaustively.
     // There is no token or node type which spans all keywords, so this is
     // significantly simpler.
 
     static $keyword_map = array(
       'true'  => 'true',
       'false' => 'false',
       'null'  => 'null',
       'array' => 'array',
       'new'   => 'new',
     );
 
     foreach ($keywords as $keyword) {
       $value = $keyword->getValue();
       $value_key = strtolower($value);
       if (!isset($keyword_map[$value_key])) {
         continue;
       }
       $expected_spelling = $keyword_map[$value_key];
       if ($value !== $expected_spelling) {
         $this->raiseLintAtToken(
           $keyword,
           self::LINT_KEYWORD_CASING,
           "Convention: spell keyword '{$value}' as '{$expected_spelling}'.",
           $expected_spelling);
       }
     }
   }
 
   private function lintStrings(XHPASTNode $root) {
     $nodes = $root->selectDescendantsOfTypes(array(
       'n_CONCATENATION_LIST',
       'n_STRING_SCALAR',
     ));
 
     foreach ($nodes as $node) {
       $strings = array();
 
       if ($node->getTypeName() === 'n_CONCATENATION_LIST') {
         $strings = $node->selectDescendantsOfType('n_STRING_SCALAR');
       } else if ($node->getTypeName() === 'n_STRING_SCALAR') {
         $strings = array($node);
 
         if ($node->getParentNode()->getTypeName() === 'n_CONCATENATION_LIST') {
           continue;
         }
       }
 
       $valid = false;
       $invalid_nodes = array();
       $fixes = array();
 
       foreach ($strings as $string) {
         $concrete_string = $string->getConcreteString();
         $single_quoted = ($concrete_string[0] === "'");
         $contents = substr($concrete_string, 1, -1);
 
         // Double quoted strings are allowed when the string contains the
         // following characters.
         static $allowed_chars = array(
           '\n',
           '\r',
           '\t',
           '\v',
           '\e',
           '\f',
           '\'',
           '\0',
           '\1',
           '\2',
           '\3',
           '\4',
           '\5',
           '\6',
           '\7',
           '\x',
         );
 
         $contains_special_chars = false;
         foreach ($allowed_chars as $allowed_char) {
           if (strpos($contents, $allowed_char) !== false) {
             $contains_special_chars = true;
           }
         }
 
         if (!$string->isConstantString()) {
           $valid = true;
         } else if ($contains_special_chars && !$single_quoted) {
           $valid = true;
         } else if (!$contains_special_chars && !$single_quoted) {
           $invalid_nodes[] = $string;
           $fixes[$string->getID()] = "'".str_replace('\"', '"', $contents)."'";
         }
       }
 
       if (!$valid) {
         foreach ($invalid_nodes as $invalid_node) {
           $this->raiseLintAtNode(
             $invalid_node,
             self::LINT_DOUBLE_QUOTE,
             pht(
               'String does not require double quotes. For consistency, '.
               'prefer single quotes.'),
             $fixes[$invalid_node->getID()]);
         }
       }
     }
   }
 
   protected function lintElseIfStatements(XHPASTNode $root) {
     $tokens = $root->selectTokensOfType('T_ELSEIF');
 
     foreach ($tokens as $token) {
       $this->raiseLintAtToken(
         $token,
         self::LINT_ELSEIF_USAGE,
         pht('Usage of `else if` is preferred over `elseif`.'),
         'else if');
     }
   }
 
   protected function lintSemicolons(XHPASTNode $root) {
     $tokens = $root->selectTokensOfType(';');
 
     foreach ($tokens as $token) {
       $prev = $token->getPrevToken();
 
       if ($prev->isAnyWhitespace()) {
         $this->raiseLintAtToken(
           $prev,
           self::LINT_SEMICOLON_SPACING,
           pht('Space found before semicolon.'),
           '');
       }
     }
   }
 
   public function getSuperGlobalNames() {
     return array(
       '$GLOBALS',
       '$_SERVER',
       '$_GET',
       '$_POST',
       '$_FILES',
       '$_COOKIE',
       '$_SESSION',
       '$_REQUEST',
       '$_ENV',
     );
   }
 
 }
diff --git a/src/lint/linter/__tests__/ArcanistLinterTestCase.php b/src/lint/linter/__tests__/ArcanistLinterTestCase.php
index 48eb173a..ae2e3e9f 100644
--- a/src/lint/linter/__tests__/ArcanistLinterTestCase.php
+++ b/src/lint/linter/__tests__/ArcanistLinterTestCase.php
@@ -1,198 +1,199 @@
 <?php
 
 /**
  * Facilitates implementation of test cases for @{class:ArcanistLinter}s.
  */
 abstract class ArcanistLinterTestCase extends ArcanistPhutilTestCase {
 
   public function executeTestsInDirectory($root, ArcanistLinter $linter) {
     $files = id(new FileFinder($root))
       ->withType('f')
       ->withSuffix('lint-test')
       ->find();
 
     $test_count = 0;
     foreach ($files as $file) {
       $this->lintFile($root.$file, $linter);
       $test_count++;
     }
 
     $this->assertTrue(
       ($test_count > 0),
       pht('Expected to find some .lint-test tests in directory %s!', $root));
   }
 
   private function lintFile($file, ArcanistLinter $linter) {
     $linter = clone $linter;
 
     $contents = Filesystem::readFile($file);
     $contents = explode("~~~~~~~~~~\n", $contents);
     if (count($contents) < 2) {
       throw new Exception(
         "Expected '~~~~~~~~~~' separating test case and results.");
     }
 
     list ($data, $expect, $xform, $config) = array_merge(
       $contents,
       array(null, null));
 
     $basename = basename($file);
 
     if ($config) {
       $config = phutil_json_decode($config);
     } else {
       $config = array();
     }
     PhutilTypeSpec::checkMap(
       $config,
       array(
         'hook' => 'optional bool',
         'config' => 'optional wild',
         'path' => 'optional string',
         'arcconfig' => 'optional map<string, string>',
       ));
 
     $exception = null;
     $after_lint = null;
     $messages = null;
     $exception_message = false;
     $caught_exception = false;
 
     try {
       $tmp = new TempFile($basename);
       Filesystem::writeFile($tmp, $data);
       $full_path = (string)$tmp;
 
       $dir = dirname($full_path);
       $path = basename($full_path);
       $config_file = null;
       $arcconfig = idx($config, 'arcconfig');
       if ($arcconfig) {
         $config_file = json_encode($arcconfig);
       }
 
       $working_copy = ArcanistWorkingCopyIdentity::newFromRootAndConfigFile(
         $dir,
         $config_file,
         'Unit Test');
       $configuration_manager = new ArcanistConfigurationManager();
       $configuration_manager->setWorkingCopyIdentity($working_copy);
 
 
       $engine = new UnitTestableArcanistLintEngine();
       $engine->setWorkingCopy($working_copy);
       $engine->setConfigurationManager($configuration_manager);
       $engine->setPaths(array($path));
 
       $engine->setCommitHookMode(idx($config, 'hook', false));
 
       $path_name = idx($config, 'path', $path);
       $linter->addPath($path_name);
       $linter->addData($path_name, $data);
       $config = idx($config, 'config', array());
       foreach ($config as $key => $value) {
         $linter->setLinterConfigurationValue($key, $value);
       }
 
       $engine->addLinter($linter);
       $engine->addFileData($path_name, $data);
 
       $results = $engine->run();
 
       $this->assertEqual(
         1,
         count($results),
         'Expect one result returned by linter.');
 
       $result = reset($results);
       $patcher = ArcanistLintPatcher::newFromArcanistLintResult($result);
       $after_lint = $patcher->getModifiedFileContent();
     } catch (ArcanistPhutilTestTerminatedException $ex) {
       throw $ex;
     } catch (Exception $exception) {
       $caught_exception = true;
       if ($exception instanceof PhutilAggregateException) {
         $caught_exception = false;
         foreach ($exception->getExceptions() as $ex) {
           if ($ex instanceof ArcanistUsageException) {
             $this->assertSkipped($ex->getMessage());
           } else {
             $caught_exception = true;
           }
         }
       } else if ($exception instanceof ArcanistUsageException) {
         $this->assertSkipped($exception->getMessage());
       }
       $exception_message = $exception->getMessage()."\n\n".
                            $exception->getTraceAsString();
     }
 
     $this->assertEqual(false, $caught_exception, $exception_message);
     $this->compareLint($basename, $expect, $result);
     $this->compareTransform($xform, $after_lint);
   }
 
   private function compareLint($file, $expect, ArcanistLintResult $result) {
     $seen = array();
     $raised = array();
     $message_map = array();
 
     foreach ($result->getMessages() as $message) {
       $sev = $message->getSeverity();
       $line = $message->getLine();
       $char = $message->getChar();
       $code = $message->getCode();
       $name = $message->getName();
       $message_key = $sev.':'.$line.':'.$char;
       $message_map[$message_key] = $message;
       $seen[] = $message_key;
       $raised[] = "  {$sev} at line {$line}, char {$char}: {$code} {$name}";
     }
     $expect = trim($expect);
     if ($expect) {
       $expect = explode("\n", $expect);
     } else {
       $expect = array();
     }
     foreach ($expect as $key => $expected) {
       $expect[$key] = head(explode(' ', $expected));
     }
 
     $expect = array_fill_keys($expect, true);
     $seen   = array_fill_keys($seen, true);
 
     if (!$raised) {
       $raised = array('No messages.');
     }
     $raised = "Actually raised:\n".implode("\n", $raised);
 
     foreach (array_diff_key($expect, $seen) as $missing => $ignored) {
       list($sev, $line, $char) = explode(':', $missing);
       $this->assertFailure(
         "In '{$file}', ".
         "expected lint to raise {$sev} on line {$line} at char {$char}, ".
         "but no {$sev} was raised. {$raised}");
     }
 
     foreach (array_diff_key($seen, $expect) as $surprising => $ignored) {
       $message = $message_map[$surprising];
       $message_info = $message->getDescription();
 
       list($sev, $line, $char) = explode(':', $surprising);
       $this->assertFailure(
         "In '{$file}', ".
         "lint raised {$sev} on line {$line} at char {$char}, ".
         "but nothing was expected:\n\n{$message_info}\n\n{$raised}");
     }
   }
 
   private function compareTransform($expected, $actual) {
     if (!strlen($expected)) {
       return;
     }
     $this->assertEqual(
       $expected,
       $actual,
       'File as patched by lint did not match the expected patched file.');
   }
+
 }
diff --git a/src/lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php b/src/lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php
index 9e70e6b4..237996ad 100644
--- a/src/lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php
+++ b/src/lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php
@@ -1,135 +1,134 @@
 <?php
 
 /**
  * You can extend this class and set `xhpast.naminghook` in your `.arclint` to
  * have an opportunity to override lint results for symbol names.
  *
  * @task override   Overriding Symbol Name Lint Messages
  * @task util       Name Utilities
  * @task internal   Internals
- * @group lint
  * @stable
  */
 abstract class ArcanistXHPASTLintNamingHook {
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
   /**
    * The constructor is final because @{class:ArcanistXHPASTLinter} is
    * responsible for hook instantiation.
    *
    * @return this
    * @task internals
    */
   final public function __construct() {
     // <empty>
   }
 
 
 /* -(  Overriding Symbol Name Lint Messages  )------------------------------- */
 
   /**
    * Callback invoked for each symbol, which can override the default
    * determination of name validity or accept it by returning $default. The
    * symbol types are: xhp-class, class, interface, function, method, parameter,
    * constant, and member.
    *
    * For example, if you want to ban all symbols with "quack" in them and
    * otherwise accept all the defaults, except allow any naming convention for
    * methods with "duck" in them, you might implement the method like this:
    *
    *   if (preg_match('/quack/i', $name)) {
    *     return 'Symbol names containing "quack" are forbidden.';
    *   }
    *   if ($type == 'method' && preg_match('/duck/i', $name)) {
    *     return null; // Always accept.
    *   }
    *   return $default;
    *
    * @param   string      The symbol type.
    * @param   string      The symbol name.
    * @param   string|null The default result from the main rule engine.
    * @return  string|null Null to accept the name, or a message to reject it
    *                      with. You should return the default value if you don't
    *                      want to specifically provide an override.
    * @task override
    */
   abstract public function lintSymbolName($type, $name, $default);
 
 
 /* -(  Name Utilities  )----------------------------------------------------- */
 
   /**
    * Returns true if a symbol name is UpperCamelCase.
    *
    * @param string Symbol name.
    * @return bool True if the symbol is UpperCamelCase.
    * @task util
    */
   public static function isUpperCamelCase($symbol) {
     return preg_match('/^[A-Z][A-Za-z0-9]*$/', $symbol);
   }
 
   /**
    * Returns true if a symbol name is lowerCamelCase.
    *
    * @param string Symbol name.
    * @return bool True if the symbol is lowerCamelCase.
    * @task util
    */
   public static function isLowerCamelCase($symbol) {
     return preg_match('/^[a-z][A-Za-z0-9]*$/', $symbol);
   }
 
   /**
    * Returns true if a symbol name is UPPERCASE_WITH_UNDERSCORES.
    *
    * @param string Symbol name.
    * @return bool True if the symbol is UPPERCASE_WITH_UNDERSCORES.
    * @task util
    */
   public static function isUppercaseWithUnderscores($symbol) {
     return preg_match('/^[A-Z0-9_]+$/', $symbol);
   }
 
   /**
    * Returns true if a symbol name is lowercase_with_underscores.
    *
    * @param string Symbol name.
    * @return bool True if the symbol is lowercase_with_underscores.
    * @task util
    */
   public static function isLowercaseWithUnderscores($symbol) {
     return preg_match('/^[a-z0-9_]+$/', $symbol);
   }
 
   /**
    * Strip non-name components from PHP function symbols. Notably, this discards
    * the "__" magic-method signifier, to make a symbol appropriate for testing
    * with methods like @{method:isLowerCamelCase}.
    *
    * @param   string Symbol name.
    * @return  string Stripped symbol.
    * @task util
    */
   public static function stripPHPFunction($symbol) {
-    //  Allow initial "__" for magic methods like __construct; we could also
-    //  enumerate these explicitly.
+    // Allow initial "__" for magic methods like __construct; we could also
+    // enumerate these explicitly.
     return preg_replace('/^__/', '', $symbol);
   }
 
   /**
    * Strip non-name components from PHP variable symbols. Notably, this discards
    * the "$", to make a symbol appropriate for testing with methods like
    * @{method:isLowercaseWithUnderscores}.
    *
    * @param string Symbol name.
    * @return string Stripped symbol.
    * @task util
    */
   public static function stripPHPVariable($symbol) {
     return preg_replace('/^\$/', '', $symbol);
   }
 
 }
diff --git a/src/lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php b/src/lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php
index e5a82ea1..7f909bb7 100644
--- a/src/lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php
+++ b/src/lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php
@@ -1,16 +1,14 @@
 <?php
 
 /**
  * You can extend this class and set `xhpast.switchhook` in your `.arclint`
  * to have an opportunity to override results for linting `switch` statements.
- *
- * @group lint
  */
 abstract class ArcanistXHPASTLintSwitchHook {
 
   /**
    * @return bool True if token safely ends the block.
    */
   abstract public function checkSwitchToken(XHPASTToken $token);
 
 }
diff --git a/src/lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php b/src/lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php
index a3f6b280..6a1d67eb 100644
--- a/src/lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php
+++ b/src/lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php
@@ -1,67 +1,65 @@
 <?php
 
 /**
  * Test cases for @{class:ArcanistXHPASTLintNamingHook}.
- *
- * @group testcase
  */
 final class ArcanistXHPASTLintNamingHookTestCase extends ArcanistTestCase {
 
   public function testCaseUtilities() {
     $tests = array(
       'UpperCamelCase'                   => array(1, 0, 0, 0),
       'UpperCamelCaseROFL'               => array(1, 0, 0, 0),
 
       'lowerCamelCase'                   => array(0, 1, 0, 0),
       'lowerCamelCaseROFL'               => array(0, 1, 0, 0),
 
       'UPPERCASE_WITH_UNDERSCORES'       => array(0, 0, 1, 0),
       '_UPPERCASE_WITH_UNDERSCORES_'     => array(0, 0, 1, 0),
       '__UPPERCASE__WITH__UNDERSCORES__' => array(0, 0, 1, 0),
 
       'lowercase_with_underscores'       => array(0, 0, 0, 1),
       '_lowercase_with_underscores_'     => array(0, 0, 0, 1),
       '__lowercase__with__underscores__' => array(0, 0, 0, 1),
 
       'mixedCASE_NoNsEnSe'               => array(0, 0, 0, 0),
     );
 
     foreach ($tests as $test => $expect) {
       $this->assertEqual(
         $expect[0],
         ArcanistXHPASTLintNamingHook::isUpperCamelCase($test),
         "UpperCamelCase: '{$test}'");
       $this->assertEqual(
         $expect[1],
         ArcanistXHPASTLintNamingHook::isLowerCamelCase($test),
         "lowerCamelCase: '{$test}'");
       $this->assertEqual(
         $expect[2],
         ArcanistXHPASTLintNamingHook::isUppercaseWithUnderscores($test),
         "UPPERCASE_WITH_UNDERSCORES: '{$test}'");
       $this->assertEqual(
         $expect[3],
         ArcanistXHPASTLintNamingHook::isLowercaseWithUnderscores($test),
         "lowercase_with_underscores: '{$test}'");
     }
   }
 
   public function testStripUtilities() {
     // Variable stripping.
     $this->assertEqual(
       'stuff',
       ArcanistXHPASTLintNamingHook::stripPHPVariable('stuff'));
     $this->assertEqual(
       'stuff',
       ArcanistXHPASTLintNamingHook::stripPHPVariable('$stuff'));
 
     // Function/method stripping.
     $this->assertEqual(
       'construct',
       ArcanistXHPASTLintNamingHook::stripPHPFunction('construct'));
     $this->assertEqual(
       'construct',
       ArcanistXHPASTLintNamingHook::stripPHPFunction('__construct'));
   }
 
 }
diff --git a/src/lint/renderer/ArcanistLintCheckstyleXMLRenderer.php b/src/lint/renderer/ArcanistLintCheckstyleXMLRenderer.php
index 29afda46..30a91485 100644
--- a/src/lint/renderer/ArcanistLintCheckstyleXMLRenderer.php
+++ b/src/lint/renderer/ArcanistLintCheckstyleXMLRenderer.php
@@ -1,56 +1,55 @@
 <?php
 
 /**
  * Shows lint messages to the user.
- *
- * @group lint
  */
 final class ArcanistLintCheckstyleXMLRenderer extends ArcanistLintRenderer {
 
   private $writer;
 
   public function __construct() {
     $this->writer = new XMLWriter();
     $this->writer->openMemory();
     $this->writer->setIndent(true);
     $this->writer->setIndentString('  ');
   }
 
   public function renderPreamble() {
     $this->writer->startDocument('1.0', 'UTF-8');
     $this->writer->startElement('checkstyle');
     $this->writer->writeAttribute('version', '4.3');
     return $this->writer->flush();
   }
 
   public function renderLintResult(ArcanistLintResult $result) {
     $this->writer->startElement('file');
     $this->writer->writeAttribute('name', $result->getPath());
 
     foreach ($result->getMessages() as $message) {
       $this->writer->startElement('error');
 
       $this->writer->writeAttribute('line', $message->getLine());
       $this->writer->writeAttribute('column', $message->getChar());
       $this->writer->writeAttribute('severity',
         ArcanistLintSeverity::getStringForSeverity($message->getSeverity()));
       $this->writer->writeAttribute('message', $message->getDescription());
       $this->writer->writeAttribute('source', $message->getCode());
 
       $this->writer->endElement();
     }
 
     $this->writer->endElement();
     return $this->writer->flush();
   }
 
   public function renderOkayResult() {
     return '';
   }
 
   public function renderPostamble() {
     $this->writer->endElement();
     $this->writer->endDocument();
     return $this->writer->flush();
   }
+
 }
diff --git a/src/lint/renderer/ArcanistLintConsoleRenderer.php b/src/lint/renderer/ArcanistLintConsoleRenderer.php
index 53db10dc..c083abd0 100644
--- a/src/lint/renderer/ArcanistLintConsoleRenderer.php
+++ b/src/lint/renderer/ArcanistLintConsoleRenderer.php
@@ -1,240 +1,240 @@
 <?php
 
 /**
  * Shows lint messages to the user.
- *
- * @group lint
  */
 final class ArcanistLintConsoleRenderer extends ArcanistLintRenderer {
+
   private $showAutofixPatches = false;
 
   public function setShowAutofixPatches($show_autofix_patches) {
     $this->showAutofixPatches = $show_autofix_patches;
     return $this;
   }
 
   public function renderLintResult(ArcanistLintResult $result) {
     $messages = $result->getMessages();
     $path = $result->getPath();
 
     $lines = explode("\n", $result->getData());
 
     $text = array();
 
     foreach ($messages as $message) {
       if (!$this->showAutofixPatches && $message->isAutofix()) {
         continue;
       }
 
       if ($message->isError()) {
         $color = 'red';
       } else {
         $color = 'yellow';
       }
 
       $severity = ArcanistLintSeverity::getStringForSeverity(
         $message->getSeverity());
       $code = $message->getCode();
       $name = $message->getName();
       $description = $message->getDescription();
 
       if ($message->getOtherLocations()) {
         $locations = array();
         foreach ($message->getOtherLocations() as $location) {
           $locations[] =
             idx($location, 'path', $path).
             (!empty($location['line']) ? ":{$location['line']}" : '');
         }
         $description .= "\nOther locations: ".implode(', ', $locations);
       }
 
       $text[] = phutil_console_format(
         "  **<bg:{$color}> %s </bg>** (%s) __%s__\n%s\n",
         $severity,
         $code,
         $name,
         phutil_console_wrap($description, 4));
 
       if ($message->hasFileContext()) {
         $text[] = $this->renderContext($message, $lines);
       }
     }
 
     if ($text) {
       $prefix = phutil_console_format("**>>>** Lint for __%s__:\n\n\n", $path);
       return $prefix.implode("\n", $text);
     } else {
       return null;
     }
   }
 
   protected function renderContext(
     ArcanistLintMessage $message,
     array $line_data) {
 
     $lines_of_context = 3;
     $out = array();
 
     $num_lines = count($line_data);
      // make line numbers line up with array indexes
     array_unshift($line_data, '');
 
     $line_num = min($message->getLine(), $num_lines);
     $line_num = max(1, $line_num);
 
     // Print out preceding context before the impacted region.
     $cursor = max(1, $line_num - $lines_of_context);
     for (; $cursor < $line_num; $cursor++) {
       $out[] = $this->renderLine($cursor, $line_data[$cursor]);
     }
 
     $text = $message->getOriginalText();
     $start = $message->getChar() - 1;
     $patch = '';
     // Refine original and replacement text to eliminate start and end in common
     if ($message->isPatchable()) {
       $patch = $message->getReplacementText();
       $text_strlen = strlen($text);
       $patch_strlen = strlen($patch);
       $min_length = min($text_strlen, $patch_strlen);
 
       $same_at_front = 0;
       for ($ii = 0; $ii < $min_length; $ii++) {
         if ($text[$ii] !== $patch[$ii]) {
           break;
         }
         $same_at_front++;
         $start++;
         if ($text[$ii] == "\n") {
           $out[] = $this->renderLine($cursor, $line_data[$cursor]);
           $cursor++;
           $start = 0;
           $line_num++;
         }
       }
       // deal with shorter string '     ' longer string '     a     '
       $min_length -= $same_at_front;
 
       // And check the end of the string
       $same_at_end = 0;
       for ($ii = 1; $ii <= $min_length; $ii++) {
         if ($text[$text_strlen - $ii] !== $patch[$patch_strlen - $ii]) {
           break;
         }
         $same_at_end++;
       }
 
       $text = substr(
         $text,
         $same_at_front,
         $text_strlen - $same_at_end - $same_at_front);
       $patch = substr(
         $patch,
         $same_at_front,
         $patch_strlen - $same_at_end - $same_at_front);
     }
     // Print out the impacted region itself.
     $diff = $message->isPatchable() ? '-' : null;
 
     $text_lines = explode("\n", $text);
     $text_length = count($text_lines);
 
     $intraline = ($text != '' || $start || !preg_match('/\n$/', $patch));
 
     if ($intraline) {
       for (; $cursor < $line_num + $text_length; $cursor++) {
         $chevron = ($cursor == $line_num);
         // We may not have any data if, e.g., the old file does not exist.
         $data = idx($line_data, $cursor, null);
 
         // Highlight the problem substring.
         $text_line = $text_lines[$cursor - $line_num];
         if (strlen($text_line)) {
           $data = substr_replace(
             $data,
             phutil_console_format('##%s##', $text_line),
             ($cursor == $line_num ? $start : 0),
             strlen($text_line));
         }
 
         $out[] = $this->renderLine($cursor, $data, $chevron, $diff);
       }
     }
 
     // Print out replacement text.
     if ($message->isPatchable()) {
       // Strip trailing newlines, since "explode" will create an extra patch
       // line for these.
       if (strlen($patch) && ($patch[strlen($patch) - 1] === "\n")) {
         $patch = substr($patch, 0, -1);
       }
       $patch_lines = explode("\n", $patch);
       $patch_length = count($patch_lines);
 
       $patch_line = $patch_lines[0];
 
       $len = isset($text_lines[0]) ? strlen($text_lines[0]) : 0;
 
       $patched = phutil_console_format('##%s##', $patch_line);
 
       if ($intraline) {
         $patched = substr_replace(
           $line_data[$line_num],
           $patched,
           $start,
           $len);
       }
 
       $out[] = $this->renderLine(null, $patched, false, '+');
 
       foreach (array_slice($patch_lines, 1) as $patch_line) {
         $out[] = $this->renderLine(
           null,
           phutil_console_format('##%s##', $patch_line), false, '+');
       }
     }
 
     $end = min($num_lines, $cursor + $lines_of_context);
     for (; $cursor < $end; $cursor++) {
       // If there is no original text, we didn't print out a chevron or any
       // highlighted text above, so print it out here. This allows messages
       // which don't have any original/replacement information to still
       // render with indicator chevrons.
       if ($text || $message->isPatchable()) {
         $chevron = false;
       } else {
         $chevron = ($cursor == $line_num);
       }
       $out[] = $this->renderLine($cursor, $line_data[$cursor], $chevron);
 
       // With original text, we'll render the text highlighted above. If the
       // lint message only has a line/char offset there's nothing to
       // highlight, so print out a caret on the next line instead.
       if ($chevron && $message->getChar()) {
         $out[] = $this->renderCaret($message->getChar());
       }
     }
     $out[] = null;
 
     return implode("\n", $out);
   }
 
   private function renderCaret($pos) {
     return str_repeat(' ', 16 + $pos).'^';
   }
 
   protected function renderLine($line, $data, $chevron = false, $diff = null) {
     $chevron = $chevron ? '>>>' : '';
     return sprintf(
       '    %3s %1s %6s %s',
       $chevron,
       $diff,
       $line,
       $data);
   }
 
   public function renderOkayResult() {
-    return
-      phutil_console_format("<bg:green>** OKAY **</bg> No lint warnings.\n");
+    return phutil_console_format(
+      "<bg:green>** OKAY **</bg> No lint warnings.\n");
   }
+
 }
diff --git a/src/lint/renderer/ArcanistLintJSONRenderer.php b/src/lint/renderer/ArcanistLintJSONRenderer.php
index bc0b68f7..7170bdc2 100644
--- a/src/lint/renderer/ArcanistLintJSONRenderer.php
+++ b/src/lint/renderer/ArcanistLintJSONRenderer.php
@@ -1,35 +1,35 @@
 <?php
 
 /**
  * Shows lint messages to the user.
- *
- * @group lint
  */
 final class ArcanistLintJSONRenderer extends ArcanistLintRenderer {
+
   const LINES_OF_CONTEXT = 3;
 
   public function renderLintResult(ArcanistLintResult $result) {
     $messages = $result->getMessages();
     $path = $result->getPath();
     $data = explode("\n", $result->getData());
     array_unshift($data, ''); // make the line numbers work as array indices
 
     $output = array($path => array());
 
     foreach ($messages as $message) {
       $dictionary = $message->toDictionary();
       $dictionary['context'] = implode("\n", array_slice(
         $data,
         max(1, $message->getLine() - self::LINES_OF_CONTEXT),
         self::LINES_OF_CONTEXT * 2 + 1));
       unset($dictionary['path']);
       $output[$path][] = $dictionary;
     }
 
     return json_encode($output)."\n";
   }
 
   public function renderOkayResult() {
     return '';
   }
+
 }
diff --git a/src/lint/renderer/ArcanistLintLikeCompilerRenderer.php b/src/lint/renderer/ArcanistLintLikeCompilerRenderer.php
index 20b328ef..5ffce5ff 100644
--- a/src/lint/renderer/ArcanistLintLikeCompilerRenderer.php
+++ b/src/lint/renderer/ArcanistLintLikeCompilerRenderer.php
@@ -1,35 +1,35 @@
 <?php
 
 /**
  * Shows lint messages to the user.
- *
- * @group lint
  */
 final class ArcanistLintLikeCompilerRenderer extends ArcanistLintRenderer {
+
   public function renderLintResult(ArcanistLintResult $result) {
     $lines = array();
     $messages = $result->getMessages();
     $path = $result->getPath();
 
     foreach ($messages as $message) {
       $severity = ArcanistLintSeverity::getStringForSeverity(
         $message->getSeverity());
       $line = $message->getLine();
       $code = $message->getCode();
       $description = $message->getDescription();
       $lines[] = sprintf(
         "%s:%d:%s (%s) %s\n",
         $path,
         $line,
         $severity,
         $code,
         $description);
     }
 
     return implode('', $lines);
   }
 
   public function renderOkayResult() {
     return '';
   }
+
 }
diff --git a/src/lint/renderer/ArcanistLintNoneRenderer.php b/src/lint/renderer/ArcanistLintNoneRenderer.php
index da44ac86..3e047bed 100644
--- a/src/lint/renderer/ArcanistLintNoneRenderer.php
+++ b/src/lint/renderer/ArcanistLintNoneRenderer.php
@@ -1,16 +1,13 @@
 <?php
 
-/**
- * @group lint
- */
 final class ArcanistLintNoneRenderer extends ArcanistLintRenderer {
 
   public function renderLintResult(ArcanistLintResult $result) {
     return '';
   }
 
   public function renderOkayResult() {
     return '';
   }
 
 }
diff --git a/src/lint/renderer/ArcanistLintRenderer.php b/src/lint/renderer/ArcanistLintRenderer.php
index 808f3128..0eced5bd 100644
--- a/src/lint/renderer/ArcanistLintRenderer.php
+++ b/src/lint/renderer/ArcanistLintRenderer.php
@@ -1,21 +1,19 @@
 <?php
 
 /**
  * Shows lint messages to the user.
- *
- * @group lint
  */
 abstract class ArcanistLintRenderer {
 
   public function renderPreamble() {
     return '';
   }
 
   abstract public function renderLintResult(ArcanistLintResult $result);
   abstract public function renderOkayResult();
 
   public function renderPostamble() {
     return '';
   }
 
 }
diff --git a/src/lint/renderer/ArcanistLintSummaryRenderer.php b/src/lint/renderer/ArcanistLintSummaryRenderer.php
index 42e1f7b2..f4ad6bba 100644
--- a/src/lint/renderer/ArcanistLintSummaryRenderer.php
+++ b/src/lint/renderer/ArcanistLintSummaryRenderer.php
@@ -1,30 +1,30 @@
 <?php
 
 /**
  * Shows lint messages to the user.
- *
- * @group lint
  */
 final class ArcanistLintSummaryRenderer extends ArcanistLintRenderer {
+
   public function renderLintResult(ArcanistLintResult $result) {
     $messages = $result->getMessages();
     $path = $result->getPath();
 
     $text = array();
     foreach ($messages as $message) {
       $name = $message->getName();
       $severity = ArcanistLintSeverity::getStringForSeverity(
         $message->getSeverity());
       $line = $message->getLine();
 
       $text[] = "{$path}:{$line}:{$severity}: {$name}\n";
     }
 
     return implode('', $text);
   }
 
   public function renderOkayResult() {
-    return
-      phutil_console_format("<bg:green>** OKAY **</bg> No lint warnings.\n");
+    return phutil_console_format(
+      "<bg:green>** OKAY **</bg> No lint warnings.\n");
   }
+
 }
diff --git a/src/parser/ArcanistBaseCommitParser.php b/src/parser/ArcanistBaseCommitParser.php
index df3331cb..7927f6b6 100644
--- a/src/parser/ArcanistBaseCommitParser.php
+++ b/src/parser/ArcanistBaseCommitParser.php
@@ -1,193 +1,192 @@
 <?php
 
 final class ArcanistBaseCommitParser {
 
   private $api;
   private $try;
   private $verbose = false;
 
   public function __construct(ArcanistRepositoryAPI $api) {
     $this->api = $api;
     return $this;
   }
 
   private function tokenizeBaseCommitSpecification($raw_spec) {
     if (!$raw_spec) {
       return array();
     }
 
     $spec = preg_split('/\s*,\s*/', $raw_spec);
     $spec = array_filter($spec);
 
     foreach ($spec as $rule) {
       if (strpos($rule, ':') === false) {
         throw new ArcanistUsageException(
           "Rule '{$rule}' is invalid, it must have a type and name like ".
           "'arc:upstream'.");
       }
     }
 
     return $spec;
   }
 
   private function log($message) {
     if ($this->verbose) {
       fwrite(STDERR, $message."\n");
     }
   }
 
   public function resolveBaseCommit(array $specs) {
     $specs += array(
       'runtime' => '',
       'local'   => '',
       'project' => '',
       'user'    => '',
       'system'  => '',
     );
 
     foreach ($specs as $source => $spec) {
       $specs[$source] = self::tokenizeBaseCommitSpecification($spec);
     }
 
     $this->try = array(
       'runtime',
       'local',
       'project',
       'user',
       'system',
     );
 
     while ($this->try) {
       $source = head($this->try);
 
       if (!idx($specs, $source)) {
         $this->log("No rules left from source '{$source}'.");
         array_shift($this->try);
         continue;
       }
 
       $this->log("Trying rules from source '{$source}'.");
 
       $rules = &$specs[$source];
       while ($rule = array_shift($rules)) {
         $this->log("Trying rule '{$rule}'.");
 
         $commit = $this->resolveRule($rule, $source);
 
         if ($commit === false) {
           // If a rule returns false, it means to go to the next ruleset.
           break;
         } else if ($commit !== null) {
           $this->log("Resolved commit '{$commit}' from rule '{$rule}'.");
           return $commit;
         }
       }
     }
 
     return null;
   }
 
   /**
    * Handle resolving individual rules.
    */
   private function resolveRule($rule, $source) {
-
     // NOTE: Returning `null` from this method means "no match".
     // Returning `false` from this method means "stop current ruleset".
 
     list($type, $name) = explode(':', $rule, 2);
     switch ($type) {
       case 'literal':
         return $name;
       case 'git':
       case 'hg':
         return $this->api->resolveBaseCommitRule($rule, $source);
       case 'arc':
         return $this->resolveArcRule($rule, $name, $source);
       default:
         throw new ArcanistUsageException(
           "Base commit rule '{$rule}' (from source '{$source}') ".
           "is not a recognized rule.");
     }
   }
 
 
   /**
    * Handle resolving "arc:*" rules.
    */
   private function resolveArcRule($rule, $name, $source) {
     $name = $this->updateLegacyRuleName($name);
 
     switch ($name) {
       case 'verbose':
         $this->verbose = true;
         $this->log('Enabled verbose mode.');
         break;
       case 'prompt':
         $reason = 'it is what you typed when prompted.';
         $this->api->setBaseCommitExplanation($reason);
         return phutil_console_prompt('Against which commit?');
       case 'local':
       case 'user':
       case 'project':
       case 'runtime':
       case 'system':
         // Push the other source on top of the list.
         array_unshift($this->try, $name);
         $this->log("Switching to source '{$name}'.");
         return false;
       case 'yield':
         // Cycle this source to the end of the list.
         $this->try[] = array_shift($this->try);
         $this->log("Yielding processing of rules from '{$source}'.");
         return false;
       case 'halt':
         // Dump the whole stack.
         $this->try = array();
         $this->log('Halting all rule processing.');
         return false;
       case 'skip':
         return null;
       case 'empty':
       case 'upstream':
       case 'outgoing':
       case 'bookmark':
       case 'amended':
       case 'this':
         return $this->api->resolveBaseCommitRule($rule, $source);
       default:
         $matches = null;
         if (preg_match('/^exec\((.*)\)$/', $name, $matches)) {
           $root = $this->api->getWorkingCopyIdentity()->getProjectRoot();
           $future = new ExecFuture('%C', $matches[1]);
           $future->setCWD($root);
           list($err, $stdout) = $future->resolve();
           if (!$err) {
             return trim($stdout);
           } else {
             return null;
           }
         } else if (preg_match('/^nodiff\((.*)\)$/', $name, $matches)) {
           return $this->api->resolveBaseCommitRule($rule, $source);
         }
 
         throw new ArcanistUsageException(
           "Base commit rule '{$rule}' (from source '{$source}') ".
           "is not a recognized rule.");
     }
   }
 
   private function updateLegacyRuleName($name) {
     $updated = array(
       'global' => 'user',
       'args'   => 'runtime',
     );
     $new_name = idx($updated, $name);
     if ($new_name) {
       $this->log("translating legacy name '$name' to '$new_name'");
       return $new_name;
     }
     return $name;
   }
 
 }
diff --git a/src/parser/ArcanistBundle.php b/src/parser/ArcanistBundle.php
index 0ea663bf..4bfd1adf 100644
--- a/src/parser/ArcanistBundle.php
+++ b/src/parser/ArcanistBundle.php
@@ -1,875 +1,869 @@
 <?php
 
 /**
  * Converts changesets between different formats.
- *
- * @group diff
  */
 final class ArcanistBundle {
 
   private $changes;
   private $conduit;
   private $blobs = array();
   private $diskPath;
   private $projectID;
   private $baseRevision;
   private $revisionID;
   private $encoding;
   private $loadFileDataCallback;
   private $authorName;
   private $authorEmail;
 
   public function setAuthorEmail($author_email) {
     $this->authorEmail = $author_email;
     return $this;
   }
 
   public function getAuthorEmail() {
     return $this->authorEmail;
   }
 
   public function setAuthorName($author_name) {
     $this->authorName = $author_name;
     return $this;
   }
 
   public function getAuthorName() {
     return $this->authorName;
   }
 
   public function getFullAuthor() {
     $author_name = $this->getAuthorName();
     if ($author_name === null) {
       return null;
     }
 
     $author_email = $this->getAuthorEmail();
     if ($author_email === null) {
       return null;
     }
 
     $full_author = sprintf('%s <%s>', $author_name, $author_email);
 
     // Because git is very picky about the author being in a valid format,
     // verify that we can parse it.
     $address = new PhutilEmailAddress($full_author);
     if (!$address->getDisplayName() || !$address->getAddress()) {
       return null;
     }
 
     return $full_author;
   }
 
   public function setConduit(ConduitClient $conduit) {
     $this->conduit = $conduit;
     return $this;
   }
 
   public function setProjectID($project_id) {
     $this->projectID = $project_id;
     return $this;
   }
 
   public function getProjectID() {
     return $this->projectID;
   }
 
   public function setBaseRevision($base_revision) {
     $this->baseRevision = $base_revision;
     return $this;
   }
 
   public function setEncoding($encoding) {
     $this->encoding = $encoding;
     return $this;
   }
 
   public function getEncoding() {
     return $this->encoding;
   }
 
   public function getBaseRevision() {
     return $this->baseRevision;
   }
 
   public function setRevisionID($revision_id) {
     $this->revisionID = $revision_id;
     return $this;
   }
 
   public function getRevisionID() {
     return $this->revisionID;
   }
 
   public static function newFromChanges(array $changes) {
     $obj = new ArcanistBundle();
     $obj->changes = $changes;
     return $obj;
   }
 
   private function getEOL($patch_type) {
-
     // NOTE: Git always generates "\n" line endings, even under Windows, and
     // can not parse certain patches with "\r\n" line endings. SVN generates
     // patches with "\n" line endings on Mac or Linux and "\r\n" line endings
     // on Windows. (This EOL style is used only for patch metadata lines, not
     // for the actual patch content.)
 
     // (On Windows, Mercurial generates \n newlines for `--git` diffs, as it
     // must, but also \n newlines for unified diffs. We never need to deal with
     // these as we use Git format for Mercurial, so this case is currently
     // ignored.)
 
     switch ($patch_type) {
       case 'git':
         return "\n";
       case 'unified':
         return phutil_is_windows() ? "\r\n" : "\n";
       default:
         throw new Exception(
           "Unknown patch type '{$patch_type}'!");
     }
   }
 
   public static function newFromArcBundle($path) {
     $path = Filesystem::resolvePath($path);
 
     $future = new ExecFuture(
       'tar tfO %s',
       $path);
     list($stdout, $file_list) = $future->resolvex();
     $file_list = explode("\n", trim($file_list));
 
     if (in_array('meta.json', $file_list)) {
       $future = new ExecFuture(
         'tar xfO %s meta.json',
         $path);
       $meta_info = $future->resolveJSON();
       $version       = idx($meta_info, 'version', 0);
       $project_name  = idx($meta_info, 'projectName');
       $base_revision = idx($meta_info, 'baseRevision');
       $revision_id   = idx($meta_info, 'revisionID');
       $encoding      = idx($meta_info, 'encoding');
       $author_name   = idx($meta_info, 'authorName');
       $author_email  = idx($meta_info, 'authorEmail');
     } else {
       // this arc bundle was probably made before we started storing meta info
       $version       = 0;
       $project_name  = null;
       $base_revision = null;
       $revision_id   = null;
       $encoding      = null;
       $author        = null;
     }
 
     $future = new ExecFuture(
       'tar xfO %s changes.json',
       $path);
     $changes = $future->resolveJSON();
 
     foreach ($changes as $change_key => $change) {
       foreach ($change['hunks'] as $key => $hunk) {
         list($hunk_data) = execx('tar xfO %s hunks/%s', $path, $hunk['corpus']);
         $changes[$change_key]['hunks'][$key]['corpus'] = $hunk_data;
       }
     }
 
     foreach ($changes as $change_key => $change) {
       $changes[$change_key] = ArcanistDiffChange::newFromDictionary($change);
     }
 
     $obj = new ArcanistBundle();
     $obj->changes = $changes;
     $obj->diskPath = $path;
     $obj->setProjectID($project_name);
     $obj->setBaseRevision($base_revision);
     $obj->setRevisionID($revision_id);
     $obj->setEncoding($encoding);
 
     return $obj;
   }
 
   public static function newFromDiff($data) {
     $obj = new ArcanistBundle();
 
     $parser = new ArcanistDiffParser();
     $obj->changes = $parser->parseDiff($data);
 
     return $obj;
   }
 
-  private function __construct() {
-
-  }
+  private function __construct() {}
 
   public function writeToDisk($path) {
     $changes = $this->getChanges();
 
     $change_list = array();
     foreach ($changes as $change) {
       $change_list[] = $change->toDictionary();
     }
 
     $hunks = array();
     foreach ($change_list as $change_key => $change) {
       foreach ($change['hunks'] as $key => $hunk) {
         $hunks[] = $hunk['corpus'];
         $change_list[$change_key]['hunks'][$key]['corpus'] = count($hunks) - 1;
       }
     }
 
     $blobs = array();
     foreach ($change_list as $change) {
       if (!empty($change['metadata']['old:binary-phid'])) {
         $blobs[$change['metadata']['old:binary-phid']] = null;
       }
       if (!empty($change['metadata']['new:binary-phid'])) {
         $blobs[$change['metadata']['new:binary-phid']] = null;
       }
     }
     foreach ($blobs as $phid => $null) {
       $blobs[$phid] = $this->getBlob($phid);
     }
 
     $meta_info = array(
       'version'      => 5,
       'projectName'  => $this->getProjectID(),
       'baseRevision' => $this->getBaseRevision(),
       'revisionID'   => $this->getRevisionID(),
       'encoding'     => $this->getEncoding(),
       'authorName'   => $this->getAuthorName(),
       'authorEmail'  => $this->getAuthorEmail(),
     );
 
     $dir = Filesystem::createTemporaryDirectory();
     Filesystem::createDirectory($dir.'/hunks');
     Filesystem::createDirectory($dir.'/blobs');
     Filesystem::writeFile($dir.'/changes.json', json_encode($change_list));
     Filesystem::writeFile($dir.'/meta.json', json_encode($meta_info));
     foreach ($hunks as $key => $hunk) {
       Filesystem::writeFile($dir.'/hunks/'.$key, $hunk);
     }
     foreach ($blobs as $key => $blob) {
       Filesystem::writeFile($dir.'/blobs/'.$key, $blob);
     }
     execx(
       '(cd %s; tar -czf %s *)',
       $dir,
       Filesystem::resolvePath($path));
     Filesystem::remove($dir);
   }
 
   public function toUnifiedDiff() {
-
     $eol = $this->getEOL('unified');
 
     $result = array();
     $changes = $this->getChanges();
     foreach ($changes as $change) {
 
       $hunk_changes = $this->buildHunkChanges($change->getHunks(), $eol);
       if (!$hunk_changes) {
         continue;
       }
 
       $old_path = $this->getOldPath($change);
       $cur_path = $this->getCurrentPath($change);
 
       $index_path = $cur_path;
       if ($index_path === null) {
         $index_path = $old_path;
       }
 
       $result[] = 'Index: '.$index_path;
       $result[] = $eol;
       $result[] = str_repeat('=', 67);
       $result[] = $eol;
 
       if ($old_path === null) {
         $old_path = '/dev/null';
       }
 
       if ($cur_path === null) {
         $cur_path = '/dev/null';
       }
 
       // When the diff is used by `patch`, `patch` ignores what is listed as the
       // current path and just makes changes to the file at the old path (unless
       // the current path is '/dev/null'.
       // If the old path and the current path aren't the same (and neither is
       // /dev/null), this indicates the file was moved or copied. By listing
       // both paths as the new file, `patch` will apply the diff to the new
       // file.
       if ($cur_path !== '/dev/null' && $old_path !== '/dev/null') {
         $old_path = $cur_path;
       }
 
       $result[] = '--- '.$old_path.$eol;
       $result[] = '+++ '.$cur_path.$eol;
 
       $result[] = $hunk_changes;
     }
 
     if (!$result) {
       return '';
     }
 
     $diff = implode('', $result);
     return $this->convertNonUTF8Diff($diff);
   }
 
   public function toGitPatch() {
     $eol = $this->getEOL('git');
 
     $result = array();
     $changes = $this->getChanges();
 
     $binary_sources = array();
     foreach ($changes as $change) {
       if (!$this->isGitBinaryChange($change)) {
         continue;
       }
 
       $type = $change->getType();
       if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY ||
           $type == ArcanistDiffChangeType::TYPE_COPY_AWAY ||
           $type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
         foreach ($change->getAwayPaths() as $path) {
           $binary_sources[$path] = $change;
         }
       }
     }
 
     foreach (array_keys($changes) as $multicopy_key) {
       $multicopy_change = $changes[$multicopy_key];
 
       $type = $multicopy_change->getType();
       if ($type != ArcanistDiffChangeType::TYPE_MULTICOPY) {
         continue;
       }
 
       // Decompose MULTICOPY into one MOVE_HERE and several COPY_HERE because
       // we need more information than we have in order to build a delete patch
       // and represent it as a bunch of COPY_HERE plus a delete. For details,
       // see T419.
 
       // Basically, MULTICOPY means there are 2 or more corresponding COPY_HERE
       // changes, so find one of them arbitrarily and turn it into a MOVE_HERE.
 
       // TODO: We might be able to do this more cleanly after T230 is resolved.
 
       $decompose_okay = false;
       foreach ($changes as $change_key => $change) {
         if ($change->getType() != ArcanistDiffChangeType::TYPE_COPY_HERE) {
           continue;
         }
         if ($change->getOldPath() != $multicopy_change->getCurrentPath()) {
           continue;
         }
         $decompose_okay = true;
         $change = clone $change;
         $change->setType(ArcanistDiffChangeType::TYPE_MOVE_HERE);
         $changes[$change_key] = $change;
 
         // The multicopy is now fully represented by MOVE_HERE plus one or more
         // COPY_HERE, so throw it away.
         unset($changes[$multicopy_key]);
         break;
       }
 
       if (!$decompose_okay) {
         throw new Exception(
           'Failed to decompose multicopy changeset in order to generate diff.');
       }
     }
 
     foreach ($changes as $change) {
       $type = $change->getType();
       $file_type = $change->getFileType();
 
       if ($file_type == ArcanistDiffChangeType::FILE_DIRECTORY) {
         // TODO: We should raise a FYI about this, so the user is aware
         // that we omitted it, if the directory is empty or has permissions
         // which git can't represent.
 
         // Git doesn't support empty directories, so we simply ignore them. If
         // the directory is nonempty, 'git apply' will create it when processing
         // the changesets for files inside it.
         continue;
       }
 
       if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY) {
         // Git will apply this in the corresponding MOVE_HERE.
         continue;
       }
 
       $old_mode = idx($change->getOldProperties(), 'unix:filemode', '100644');
       $new_mode = idx($change->getNewProperties(), 'unix:filemode', '100644');
 
       $is_binary = $this->isGitBinaryChange($change);
 
       if ($is_binary) {
         $old_binary = idx($binary_sources, $this->getCurrentPath($change));
         $change_body = $this->buildBinaryChange($change, $old_binary);
       } else {
         $change_body = $this->buildHunkChanges($change->getHunks(), $eol);
       }
       if ($type == ArcanistDiffChangeType::TYPE_COPY_AWAY) {
         // TODO: This is only relevant when patching old Differential diffs
         // which were created prior to arc pruning TYPE_COPY_AWAY for files
         // with no modifications.
         if (!strlen($change_body) && ($old_mode == $new_mode)) {
           continue;
         }
       }
 
       $old_path = $this->getOldPath($change);
       $cur_path = $this->getCurrentPath($change);
 
       if ($old_path === null) {
         $old_index = 'a/'.$cur_path;
         $old_target  = '/dev/null';
       } else {
         $old_index = 'a/'.$old_path;
         $old_target  = 'a/'.$old_path;
       }
 
       if ($cur_path === null) {
         $cur_index = 'b/'.$old_path;
         $cur_target  = '/dev/null';
       } else {
         $cur_index = 'b/'.$cur_path;
         $cur_target  = 'b/'.$cur_path;
       }
 
       $result[] = "diff --git {$old_index} {$cur_index}".$eol;
 
       if ($type == ArcanistDiffChangeType::TYPE_ADD) {
         $result[] = "new file mode {$new_mode}".$eol;
       }
 
       if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE ||
           $type == ArcanistDiffChangeType::TYPE_MOVE_HERE ||
           $type == ArcanistDiffChangeType::TYPE_COPY_AWAY ||
           $type == ArcanistDiffChangeType::TYPE_CHANGE) {
         if ($old_mode !== $new_mode) {
           $result[] = "old mode {$old_mode}".$eol;
           $result[] = "new mode {$new_mode}".$eol;
         }
       }
 
       if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
         $result[] = "copy from {$old_path}".$eol;
         $result[] = "copy to {$cur_path}".$eol;
       } else if ($type == ArcanistDiffChangeType::TYPE_MOVE_HERE) {
         $result[] = "rename from {$old_path}".$eol;
         $result[] = "rename to {$cur_path}".$eol;
       } else if ($type == ArcanistDiffChangeType::TYPE_DELETE ||
                  $type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
         $old_mode = idx($change->getOldProperties(), 'unix:filemode');
         if ($old_mode) {
           $result[] = "deleted file mode {$old_mode}".$eol;
         }
       }
 
       if ($change_body) {
         if (!$is_binary) {
           $result[] = "--- {$old_target}".$eol;
           $result[] = "+++ {$cur_target}".$eol;
         }
         $result[] = $change_body;
       }
     }
 
     $diff = implode('', $result).$eol;
     return $this->convertNonUTF8Diff($diff);
   }
 
   private function isGitBinaryChange(ArcanistDiffChange $change) {
     $file_type = $change->getFileType();
     return ($file_type == ArcanistDiffChangeType::FILE_BINARY ||
             $file_type == ArcanistDiffChangeType::FILE_IMAGE);
   }
 
   private function convertNonUTF8Diff($diff) {
     if ($this->encoding) {
       $diff = phutil_utf8_convert($diff, $this->encoding, 'UTF-8');
     }
     return $diff;
   }
 
   public function getChanges() {
     return $this->changes;
   }
 
   private function breakHunkIntoSmallHunks(ArcanistDiffHunk $base_hunk) {
     $context = 3;
 
     $results = array();
     $lines = phutil_split_lines($base_hunk->getCorpus());
     $n = count($lines);
 
     $old_offset = $base_hunk->getOldOffset();
     $new_offset = $base_hunk->getNewOffset();
 
     $ii = 0;
     $jj = 0;
     while ($ii < $n) {
       // Skip lines until we find the next line with changes. Note: this skips
       // both ' ' (no changes) and '\' (no newline at end of file) lines. If we
       // don't skip the latter, we may incorrectly generate a terminal hunk
       // that has no actual change information when a file doesn't have a
       // terminal newline and not changed near the end of the file. 'patch' will
       // fail to apply the diff if we generate a hunk that does not actually
       // contain changes.
       for ($jj = $ii; $jj < $n; ++$jj) {
         $char = $lines[$jj][0];
         if ($char == '-' || $char == '+') {
           break;
         }
       }
       if ($jj >= $n) {
         break;
       }
 
       $hunk_start = max($jj - $context, 0);
 
 
       // NOTE: There are two tricky considerations here.
       // We can not generate a patch with overlapping hunks, or 'git apply'
       // rejects it after 1.7.3.4.
       // We can not generate a patch with too much trailing context, or
       // 'patch' rejects it.
       // So we need to ensure that we generate disjoint hunks, but don't
       // generate any hunks with too much context.
 
       $old_lines = 0;
       $new_lines = 0;
       $hunk_adjust = 0;
       $last_change = $jj;
       $break_here = null;
       for (; $jj < $n; ++$jj) {
         if ($lines[$jj][0] == ' ') {
 
           if ($jj - $last_change > $context) {
             if ($break_here === null) {
               // We haven't seen a change in $context lines, so this is a
               // potential place to break the hunk. However, we need to keep
               // looking in case there is another change fewer than $context
               // lines away, in which case we have to merge the hunks.
               $break_here = $jj;
             }
           }
 
           if ($jj - $last_change > (($context + 1) * 2)) {
             // We definitely aren't going to merge this with the next hunk, so
             // break out of the loop. We'll end the hunk at $break_here.
             break;
           }
         } else {
           $break_here = null;
           $last_change = $jj;
 
           if ($lines[$jj][0] == '\\') {
             // When we have a "\ No newline at end of file" line, it does not
             // contribute to either hunk length.
             ++$hunk_adjust;
           } else if ($lines[$jj][0] == '-') {
             ++$old_lines;
           } else if ($lines[$jj][0] == '+') {
             ++$new_lines;
           }
         }
       }
 
       if ($break_here !== null) {
         $jj = $break_here;
       }
 
       $hunk_length = min($jj, $n) - $hunk_start;
       $count_length = ($hunk_length - $hunk_adjust);
 
       $hunk = new ArcanistDiffHunk();
       $hunk->setOldOffset($old_offset + $hunk_start - $ii);
       $hunk->setNewOffset($new_offset + $hunk_start - $ii);
       $hunk->setOldLength($count_length - $new_lines);
       $hunk->setNewLength($count_length - $old_lines);
 
       $corpus = array_slice($lines, $hunk_start, $hunk_length);
       $corpus = implode('', $corpus);
       $hunk->setCorpus($corpus);
 
       $results[] = $hunk;
 
       $old_offset += ($jj - $ii) - $new_lines;
       $new_offset += ($jj - $ii) - $old_lines;
       $ii = $jj;
     }
 
     return $results;
   }
 
   private function getOldPath(ArcanistDiffChange $change) {
     $old_path = $change->getOldPath();
     $type = $change->getType();
 
     if (!strlen($old_path) ||
         $type == ArcanistDiffChangeType::TYPE_ADD) {
       $old_path = null;
     }
 
     return $old_path;
   }
 
   private function getCurrentPath(ArcanistDiffChange $change) {
     $cur_path = $change->getCurrentPath();
     $type = $change->getType();
 
     if (!strlen($cur_path) ||
         $type == ArcanistDiffChangeType::TYPE_DELETE ||
         $type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
       $cur_path = null;
     }
 
     return $cur_path;
   }
 
   private function buildHunkChanges(array $hunks, $eol) {
     assert_instances_of($hunks, 'ArcanistDiffHunk');
     $result = array();
     foreach ($hunks as $hunk) {
       $small_hunks = $this->breakHunkIntoSmallHunks($hunk);
       foreach ($small_hunks as $small_hunk) {
         $o_off = $small_hunk->getOldOffset();
         $o_len = $small_hunk->getOldLength();
         $n_off = $small_hunk->getNewOffset();
         $n_len = $small_hunk->getNewLength();
         $corpus = $small_hunk->getCorpus();
 
         // NOTE: If the length is 1 it can be omitted. Since git does this,
         // we also do it so that "arc export --git" diffs are as similar to
         // real git diffs as possible, which helps debug issues.
 
         if ($o_len == 1) {
           $o_head = "{$o_off}";
         } else {
           $o_head = "{$o_off},{$o_len}";
         }
 
         if ($n_len == 1) {
           $n_head = "{$n_off}";
         } else {
           $n_head = "{$n_off},{$n_len}";
         }
 
         $result[] = "@@ -{$o_head} +{$n_head} @@".$eol;
         $result[] = $corpus;
 
         $last = substr($corpus, -1);
         if ($last !== false && $last != "\r" && $last != "\n") {
           $result[] = $eol;
         }
       }
     }
     return implode('', $result);
   }
 
   public function setLoadFileDataCallback($callback) {
     $this->loadFileDataCallback = $callback;
     return $this;
   }
 
   private function getBlob($phid, $name = null) {
     if ($this->loadFileDataCallback) {
       return call_user_func($this->loadFileDataCallback, $phid);
     }
 
     if ($this->diskPath) {
       list($blob_data) = execx('tar xfO %s blobs/%s', $this->diskPath, $phid);
       return $blob_data;
     }
 
     $console = PhutilConsole::getConsole();
 
     if ($this->conduit) {
       if ($name) {
         $console->writeErr("Downloading binary data for '%s'...\n", $name);
       } else {
         $console->writeErr("Downloading binary data...\n");
       }
       $data_base64 = $this->conduit->callMethodSynchronous(
         'file.download',
         array(
           'phid' => $phid,
         ));
       return base64_decode($data_base64);
     }
 
     throw new Exception("Nowhere to load blob '{$phid}' from!");
   }
 
   private function buildBinaryChange(ArcanistDiffChange $change, $old_binary) {
     $eol = $this->getEOL('git');
 
     // In Git, when we write out a binary file move or copy, we need the
     // original binary for the source and the current binary for the
     // destination.
 
     if ($old_binary) {
       if ($old_binary->getOriginalFileData() !== null) {
         $old_data = $old_binary->getOriginalFileData();
         $old_phid = null;
       } else {
         $old_data = null;
         $old_phid = $old_binary->getMetadata('old:binary-phid');
       }
     } else {
       $old_data = $change->getOriginalFileData();
       $old_phid = $change->getMetadata('old:binary-phid');
     }
 
     if ($old_data === null && $old_phid) {
       $name = basename($change->getOldPath());
       $old_data = $this->getBlob($old_phid, $name);
     }
 
     $old_length = strlen($old_data);
 
     if ($old_data === null) {
       $old_data = '';
       $old_sha1 = str_repeat('0', 40);
     } else {
       $old_sha1 = sha1("blob {$old_length}\0{$old_data}");
     }
 
     $new_phid = $change->getMetadata('new:binary-phid');
 
     $new_data = null;
     if ($change->getCurrentFileData() !== null) {
       $new_data = $change->getCurrentFileData();
     } else if ($new_phid) {
       $name = basename($change->getCurrentPath());
       $new_data = $this->getBlob($new_phid, $name);
     }
 
     $new_length = strlen($new_data);
 
     if ($new_data === null) {
       $new_data = '';
       $new_sha1 = str_repeat('0', 40);
     } else {
       $new_sha1 = sha1("blob {$new_length}\0{$new_data}");
     }
 
     $content = array();
     $content[] = "index {$old_sha1}..{$new_sha1}".$eol;
     $content[] = 'GIT binary patch'.$eol;
 
     $content[] = "literal {$new_length}".$eol;
     $content[] = $this->emitBinaryDiffBody($new_data).$eol;
 
     $content[] = "literal {$old_length}".$eol;
     $content[] = $this->emitBinaryDiffBody($old_data).$eol;
 
     return implode('', $content);
   }
 
   private function emitBinaryDiffBody($data) {
     $eol = $this->getEOL('git');
 
     if (!function_exists('gzcompress')) {
       throw new Exception(
         'This patch has binary data. The PHP zlib extension is required to '.
         'apply patches with binary data to git. Install the PHP zlib '.
         'extension to continue.');
     }
 
     // See emit_binary_diff_body() in diff.c for git's implementation.
 
     $buf = '';
 
     $deflated = gzcompress($data);
     $lines = str_split($deflated, 52);
     foreach ($lines as $line) {
       $len = strlen($line);
       // The first character encodes the line length.
       if ($len <= 26) {
         $buf .= chr($len + ord('A') - 1);
       } else {
         $buf .= chr($len - 26 + ord('a') - 1);
       }
       $buf .= self::encodeBase85($line);
       $buf .= $eol;
     }
 
     return $buf;
   }
 
   public static function encodeBase85($data) {
     // This is implemented awkwardly in order to closely mirror git's
     // implementation in base85.c
 
     // It is also implemeted awkwardly to work correctly on 32-bit machines.
     // Broadly, this algorithm converts the binary input to printable output
     // by transforming each 4 binary bytes of input to 5 printable bytes of
     // output, one piece at a time.
     //
     // To do this, we convert the 4 bytes into a 32-bit integer, then use
     // modulus and division by 85 to pick out printable bytes (85^5 is slightly
     // larger than 2^32). In C, this algorithm is fairly easy to implement
     // because the accumulator can be made unsigned.
     //
     // In PHP, there are no unsigned integers, so values larger than 2^31 break
     // on 32-bit systems under modulus:
     //
     //   $ php -r 'print (1 << 31) % 13;' # On a 32-bit machine.
     //   -11
     //
     // However, PHP's float type is an IEEE 754 64-bit double precision float,
     // so we can safely store integers up to around 2^53 without loss of
     // precision. To work around the lack of an unsigned type, we just use a
     // double and perform the modulus with fmod().
     //
     // (Since PHP overflows integer operations into floats, we don't need much
     // additional casting.)
 
     static $map = array(
       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
       'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
       'U', 'V', 'W', 'X', 'Y', 'Z',
       'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
       'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
       'u', 'v', 'w', 'x', 'y', 'z',
       '!', '#', '$', '%', '&', '(', ')', '*', '+', '-',
       ';', '<', '=', '>', '?', '@', '^', '_', '`', '{',
       '|', '}', '~',
     );
 
     $buf = '';
 
     $pos = 0;
     $bytes = strlen($data);
     while ($bytes) {
       $accum = 0;
       for ($count = 24; $count >= 0; $count -= 8) {
         $val = ord($data[$pos++]);
         $val = $val * (1 << $count);
         $accum = $accum + $val;
         if (--$bytes == 0) {
           break;
         }
       }
       $slice = '';
       for ($count = 4; $count >= 0; $count--) {
         $val = (int)fmod($accum, 85.0);
         $accum = floor($accum / 85.0);
         $slice .= $map[$val];
       }
       $buf .= strrev($slice);
     }
 
     return $buf;
   }
 
 }
diff --git a/src/parser/ArcanistDiffParser.php b/src/parser/ArcanistDiffParser.php
index 7c772687..f9f9e441 100644
--- a/src/parser/ArcanistDiffParser.php
+++ b/src/parser/ArcanistDiffParser.php
@@ -1,1412 +1,1408 @@
 <?php
 
 /**
  * Parses diffs from a working copy.
- *
- * @group diff
  */
 final class ArcanistDiffParser {
 
   protected $repositoryAPI;
   protected $text;
   protected $line;
   protected $lineSaved;
   protected $isGit;
   protected $isMercurial;
   protected $isRCS;
   protected $detectBinaryFiles = false;
   protected $tryEncoding;
   protected $rawDiff;
   protected $writeDiffOnFailure;
 
   protected $changes = array();
   private $forcePath;
 
   public function setRepositoryAPI(ArcanistRepositoryAPI $repository_api) {
     $this->repositoryAPI = $repository_api;
     return $this;
   }
 
   public function setDetectBinaryFiles($detect) {
     $this->detectBinaryFiles = $detect;
     return $this;
   }
 
   public function setTryEncoding($encoding) {
     $this->tryEncoding = $encoding;
     return $this;
   }
 
   public function forcePath($path) {
     $this->forcePath = $path;
     return $this;
   }
 
   public function setChanges(array $changes) {
     assert_instances_of($changes, 'ArcanistDiffChange');
     $this->changes = mpull($changes, null, 'getCurrentPath');
     return $this;
   }
 
   public function parseSubversionDiff(ArcanistSubversionAPI $api, $paths) {
     $this->setRepositoryAPI($api);
 
     $diffs = array();
 
     foreach ($paths as $path => $status) {
       if ($status & ArcanistRepositoryAPI::FLAG_UNTRACKED ||
           $status & ArcanistRepositoryAPI::FLAG_CONFLICT ||
           $status & ArcanistRepositoryAPI::FLAG_MISSING) {
         unset($paths[$path]);
       }
     }
 
     $root = null;
     $from = array();
     foreach ($paths as $path => $status) {
       $change = $this->buildChange($path);
 
       if ($status & ArcanistRepositoryAPI::FLAG_ADDED) {
         $change->setType(ArcanistDiffChangeType::TYPE_ADD);
       } else if ($status & ArcanistRepositoryAPI::FLAG_DELETED) {
         $change->setType(ArcanistDiffChangeType::TYPE_DELETE);
       } else {
         $change->setType(ArcanistDiffChangeType::TYPE_CHANGE);
       }
 
       $is_dir = is_dir($api->getPath($path));
       if ($is_dir) {
         $change->setFileType(ArcanistDiffChangeType::FILE_DIRECTORY);
         // We have to go hit the diff even for directories because they may
         // have property changes or moves, etc.
       }
       $is_link = is_link($api->getPath($path));
       if ($is_link) {
         $change->setFileType(ArcanistDiffChangeType::FILE_SYMLINK);
       }
 
       $diff = $api->getRawDiffText($path);
       if ($diff) {
         $this->parseDiff($diff);
       }
 
       $info = $api->getSVNInfo($path);
       if (idx($info, 'Copied From URL')) {
         if (!$root) {
           $rinfo = $api->getSVNInfo('.');
           $root = $rinfo['URL'].'/';
         }
         $cpath = $info['Copied From URL'];
         $root_len = strlen($root);
         if (!strncmp($cpath, $root, $root_len)) {
           $cpath = substr($cpath, $root_len);
           // The user can "svn cp /path/to/file@12345 x", which pulls a file out
           // of version history at a specific revision. If we just use the path,
           // we'll collide with possible changes to that path in the working
           // copy below. In particular, "svn cp"-ing a path which no longer
           // exists somewhere in the working copy and then adding that path
           // gets us to the "origin change type" branches below with a
           // TYPE_ADD state on the path. To avoid this, append the origin
           // revision to the path so we'll necessarily generate a new change.
           // TODO: In theory, you could have an '@' in your path and this could
           // cause a collision, e.g. two files named 'f' and 'f@12345'. This is
           // at least somewhat the user's fault, though.
           if ($info['Copied From Rev']) {
             if ($info['Copied From Rev'] != $info['Revision']) {
               $cpath .= '@'.$info['Copied From Rev'];
             }
           }
           $change->setOldPath($cpath);
           $from[$path] = $cpath;
         }
       }
 
       $type = $change->getType();
       if (($type === ArcanistDiffChangeType::TYPE_MOVE_AWAY ||
            $type === ArcanistDiffChangeType::TYPE_DELETE) &&
           idx($info, 'Node Kind') === 'directory') {
         $change->setFileType(ArcanistDiffChangeType::FILE_DIRECTORY);
       }
     }
 
     foreach ($paths as $path => $status) {
       $change = $this->buildChange($path);
       if (empty($from[$path])) {
         continue;
       }
 
       if (empty($this->changes[$from[$path]])) {
         if ($change->getType() == ArcanistDiffChangeType::TYPE_COPY_HERE) {
           // If the origin path wasn't changed (or isn't included in this diff)
           // and we only copied it, don't generate a changeset for it. This
           // keeps us out of trouble when we go to 'arc commit' and need to
           // figure out which files should be included in the commit list.
           continue;
         }
       }
 
       $origin = $this->buildChange($from[$path]);
       $origin->addAwayPath($change->getCurrentPath());
 
       $type = $origin->getType();
       switch ($type) {
         case ArcanistDiffChangeType::TYPE_MULTICOPY:
         case ArcanistDiffChangeType::TYPE_COPY_AWAY:
         // "Add" is possible if you do some bizarre tricks with svn:ignore and
         // "svn copy"'ing URLs straight from the repository; you can end up with
         // a file that is a copy of itself. See T271.
         case ArcanistDiffChangeType::TYPE_ADD:
           break;
         case ArcanistDiffChangeType::TYPE_DELETE:
           $origin->setType(ArcanistDiffChangeType::TYPE_MOVE_AWAY);
           break;
         case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
           $origin->setType(ArcanistDiffChangeType::TYPE_MULTICOPY);
           break;
         case ArcanistDiffChangeType::TYPE_CHANGE:
           $origin->setType(ArcanistDiffChangeType::TYPE_COPY_AWAY);
           break;
         default:
           throw new Exception("Bad origin state {$type}.");
       }
 
       $type = $origin->getType();
       switch ($type) {
         case ArcanistDiffChangeType::TYPE_MULTICOPY:
         case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
           $change->setType(ArcanistDiffChangeType::TYPE_MOVE_HERE);
           break;
         case ArcanistDiffChangeType::TYPE_ADD:
         case ArcanistDiffChangeType::TYPE_COPY_AWAY:
           $change->setType(ArcanistDiffChangeType::TYPE_COPY_HERE);
           break;
         default:
           throw new Exception("Bad origin state {$type}.");
       }
     }
 
     return $this->changes;
   }
 
   public function parseDiff($diff) {
     if (!strlen(trim($diff))) {
       throw new Exception("Can't parse an empty diff!");
     }
 
     // Detect `git-format-patch`, by looking for a "---" line somewhere in
     // the file and then a footer with Git version number, which looks like
     // this:
     //
     //   --
     //   1.8.4.2
     //
     // Note that `git-format-patch` adds a space after the "--", but we don't
     // require it when detecting patches, as trailing whitespace can easily be
     // lost in transit.
     $detect_patch = '/^---$.*^-- ?[\s\d.]+\z/ms';
     $message = null;
     if (preg_match($detect_patch, $diff)) {
       list($message, $diff) = $this->stripGitFormatPatch($diff);
     }
 
     $this->didStartParse($diff);
 
     // Strip off header comments. While `patch` allows comments anywhere in the
     // file, `git apply` is more strict. We get these comments in `hg export`
     // diffs, and Eclipse can also produce them.
     $line = $this->getLineTrimmed();
     while (preg_match('/^#/', $line)) {
       $line = $this->nextLine();
     }
 
     if (strlen($message)) {
       // If we found a message during pre-parse steps, add it to the resulting
       // changes here.
       $change = $this->buildChange(null)
         ->setType(ArcanistDiffChangeType::TYPE_MESSAGE)
         ->setMetadata('message', $message);
     }
 
     do {
       $patterns = array(
         // This is a normal SVN text change, probably from "svn diff".
         '(?P<type>Index): (?P<cur>.+)',
         // This is an SVN text change, probably from "svnlook diff".
         '(?P<type>Modified|Added|Deleted|Copied): (?P<cur>.+)',
         // This is an SVN property change, probably from "svn diff".
         '(?P<type>Property changes on): (?P<cur>.+)',
         // This is a git commit message, probably from "git show".
         '(?P<type>commit) (?P<hash>[a-f0-9]+)(?: \(.*\))?',
         // This is a git diff, probably from "git show" or "git diff".
         // Note that the filenames may appear quoted.
         '(?P<type>diff --git) (?P<oldnew>.*)',
         // RCS Diff
         '(?P<type>rcsdiff -u) (?P<oldnew>.*)',
         // This is a unified diff, probably from "diff -u" or synthetic diffing.
         '(?P<type>---) (?P<old>.+)\s+\d{4}-\d{2}-\d{2}.*',
         '(?P<binary>Binary files|Files) '.
           '(?P<old>.+)\s+\d{4}-\d{2}-\d{2} and '.
           '(?P<new>.+)\s+\d{4}-\d{2}-\d{2} differ.*',
         // This is a normal Mercurial text change, probably from "hg diff". It
         // may have two "-r" blocks if it came from "hg diff -r x:y".
         '(?P<type>diff -r) (?P<hgrev>[a-f0-9]+) (?:-r [a-f0-9]+ )?(?P<cur>.+)',
       );
 
       $line = $this->getLineTrimmed();
       $match = null;
       $ok = $this->tryMatchHeader($patterns, $line, $match);
 
       $failed_parse = false;
       if (!$ok && $this->isFirstNonEmptyLine()) {
         // 'hg export' command creates so called "extended diff" that
         // contains some meta information and comment at the beginning
         // (isFirstNonEmptyLine() to check for beginning). Actual mercurial
         // code detects where comment ends and unified diff starts by
         // searching for "diff -r" or "diff --git" in the text.
         $this->saveLine();
         $line = $this->nextLineThatLooksLikeDiffStart();
         if (!$this->tryMatchHeader($patterns, $line, $match)) {
           // Restore line before guessing to display correct error.
           $this->restoreLine();
           $failed_parse = true;
         }
       } else if (!$ok) {
         $failed_parse = true;
       }
 
       if ($failed_parse) {
         $this->didFailParse(
           "Expected a hunk header, like 'Index: /path/to/file.ext' (svn), ".
           "'Property changes on: /path/to/file.ext' (svn properties), ".
           "'commit 59bcc3ad6775562f845953cf01624225' (git show), ".
           "'diff --git' (git diff), '--- filename' (unified diff), or ".
           "'diff -r' (hg diff or patch).");
       }
 
       if (isset($match['type'])) {
         if ($match['type'] == 'diff --git') {
           list($old, $new) = self::splitGitDiffPaths($match['oldnew']);
           $match['old'] = $old;
           $match['cur'] = $new;
         }
       }
 
       $change = $this->buildChange(idx($match, 'cur'));
 
       if (isset($match['old'])) {
         $change->setOldPath($match['old']);
       }
 
       if (isset($match['hash'])) {
         $change->setCommitHash($match['hash']);
       }
 
       if (isset($match['binary'])) {
         $change->setFileType(ArcanistDiffChangeType::FILE_BINARY);
         $line = $this->nextNonemptyLine();
         continue;
       }
 
       $line = $this->nextLine();
 
       switch ($match['type']) {
         case 'Index':
         case 'Modified':
         case 'Added':
         case 'Deleted':
         case 'Copied':
           $this->parseIndexHunk($change);
           break;
         case 'Property changes on':
           $this->parsePropertyHunk($change);
           break;
         case 'diff --git':
           $this->setIsGit(true);
           $this->parseIndexHunk($change);
           break;
         case 'commit':
           $this->setIsGit(true);
           $this->parseCommitMessage($change);
           break;
         case '---':
           $ok = preg_match(
             '@^(?:\+\+\+) (.*)\s+\d{4}-\d{2}-\d{2}.*$@',
             $line,
             $match);
           if (!$ok) {
             $this->didFailParse("Expected '+++ filename' in unified diff.");
           }
           $change->setCurrentPath($match[1]);
           $line = $this->nextLine();
           $this->parseChangeset($change);
           break;
         case 'diff -r':
           $this->setIsMercurial(true);
           $this->parseIndexHunk($change);
           break;
         case 'rcsdiff -u':
           $this->isRCS = true;
           $this->parseIndexHunk($change);
           break;
         default:
           $this->didFailParse('Unknown diff type.');
           break;
       }
     } while ($this->getLine() !== null);
 
     $this->didFinishParse();
 
     $this->loadSyntheticData();
 
     return $this->changes;
   }
 
   protected function tryMatchHeader($patterns, $line, &$match) {
     foreach ($patterns as $pattern) {
       if (preg_match('@^'.$pattern.'$@', $line, $match)) {
         return true;
       }
     }
     return false;
   }
 
   protected function parseCommitMessage(ArcanistDiffChange $change) {
     $change->setType(ArcanistDiffChangeType::TYPE_MESSAGE);
 
     $message = array();
 
     $line = $this->getLine();
     if (preg_match('/^Merge: /', $line)) {
       $this->nextLine();
     }
 
     $line = $this->getLine();
     if (!preg_match('/^Author: /', $line)) {
       $this->didFailParse("Expected 'Author:'.");
     }
 
     $line = $this->nextLine();
     if (!preg_match('/^Date: /', $line)) {
       $this->didFailParse("Expected 'Date:'.");
     }
 
     while (($line = $this->nextLineTrimmed()) !== null) {
       if (strlen($line) && $line[0] != ' ') {
         break;
       }
 
       // Strip leading spaces from Git commit messages. Note that empty lines
       // are represented as just "\n"; don't touch those.
       $message[] = preg_replace('/^    /', '', $this->getLine());
     }
 
     $message = rtrim(implode('', $message), "\r\n");
     $change->setMetadata('message', $message);
   }
 
   /**
    * Parse an SVN property change hunk. These hunks are ambiguous so just sort
    * of try to get it mostly right. It's entirely possible to foil this parser
    * (or any other parser) with a carefully constructed property change.
    */
   protected function parsePropertyHunk(ArcanistDiffChange $change) {
     $line = $this->getLineTrimmed();
     if (!preg_match('/^_+$/', $line)) {
       $this->didFailParse("Expected '______________________'.");
     }
 
     $line = $this->nextLine();
     while ($line !== null) {
       $done = preg_match('/^(Index|Property changes on):/', $line);
       if ($done) {
         break;
       }
 
       // NOTE: Before 1.5, SVN uses "Name". At 1.5 and later, SVN uses
       // "Modified", "Added" and "Deleted".
 
       $matches = null;
       $ok = preg_match(
         '/^(Name|Modified|Added|Deleted): (.*)$/',
         $line,
         $matches);
       if (!$ok) {
         $this->didFailParse(
           "Expected 'Name', 'Added', 'Deleted', or 'Modified'.");
       }
 
       $op = $matches[1];
       $prop = $matches[2];
 
       list($old, $new) = $this->parseSVNPropertyChange($op, $prop);
 
       if ($old !== null) {
         $change->setOldProperty($prop, $old);
       }
 
       if ($new !== null) {
         $change->setNewProperty($prop, $new);
       }
 
       $line = $this->getLine();
     }
   }
 
   private function parseSVNPropertyChange($op, $prop) {
-
     $old = array();
     $new = array();
 
     $target = null;
 
     $line = $this->nextLine();
     $prop_index = 2;
     while ($line !== null) {
       $done = preg_match(
         '/^(Modified|Added|Deleted|Index|Property changes on):/',
         $line);
       if ($done) {
         break;
       }
       $trimline = ltrim($line);
       if ($trimline && $trimline[0] == '#') {
         // in svn1.7, a line like ## -0,0 +1 ## is put between the Added: line
         // and the line with the property change. If we have such a line, we'll
         // just ignore it (:
         $line = $this->nextLine();
         $prop_index = 1;
         $trimline = ltrim($line);
       }
       if ($trimline && $trimline[0] == '+') {
         if ($op == 'Deleted') {
           $this->didFailParse('Unexpected "+" section in property deletion.');
         }
         $target = 'new';
         $line = substr($trimline, $prop_index);
       } else if ($trimline && $trimline[0] == '-') {
         if ($op == 'Added') {
           $this->didFailParse('Unexpected "-" section in property addition.');
         }
         $target = 'old';
         $line = substr($trimline, $prop_index);
       } else if (!strncmp($trimline, 'Merged', 6)) {
         if ($op == 'Added') {
           $target = 'new';
         } else {
           // These can appear on merges. No idea how to interpret this (unclear
           // what the old / new values are) and it's of dubious usefulness so
           // just throw it away until someone complains.
           $target = null;
         }
         $line = $trimline;
       }
 
       if ($target == 'new') {
         $new[] = $line;
       } else if ($target == 'old') {
         $old[] = $line;
       }
 
       $line = $this->nextLine();
     }
 
     $old = rtrim(implode('', $old));
     $new = rtrim(implode('', $new));
 
     if (!strlen($old)) {
       $old = null;
     }
 
     if (!strlen($new)) {
       $new = null;
     }
 
     return array($old, $new);
   }
 
   protected function setIsGit($git) {
     if ($this->isGit !== null && $this->isGit != $git) {
       throw new Exception('Git status has changed!');
     }
     $this->isGit = $git;
     return $this;
   }
 
   protected function getIsGit() {
     return $this->isGit;
   }
 
   public function setIsMercurial($is_mercurial) {
     $this->isMercurial = $is_mercurial;
     return $this;
   }
 
   public function getIsMercurial() {
     return $this->isMercurial;
   }
 
   protected function parseIndexHunk(ArcanistDiffChange $change) {
     $is_git = $this->getIsGit();
     $is_mercurial = $this->getIsMercurial();
     $is_svn = (!$is_git && !$is_mercurial);
 
     $move_source = null;
 
     $line = $this->getLine();
     if ($is_git) {
       do {
 
         $patterns = array(
           '(?P<new>new) file mode (?P<newmode>\d+)',
           '(?P<deleted>deleted) file mode (?P<oldmode>\d+)',
           // These occur when someone uses `chmod` on a file.
           'old mode (?P<oldmode>\d+)',
           'new mode (?P<newmode>\d+)',
           // These occur when you `mv` a file and git figures it out.
           'similarity index ',
           'rename from (?P<old>.*)',
           '(?P<move>rename) to (?P<cur>.*)',
           'copy from (?P<old>.*)',
           '(?P<copy>copy) to (?P<cur>.*)'
         );
 
         $ok = false;
         $match = null;
         foreach ($patterns as $pattern) {
           $ok = preg_match('@^'.$pattern.'@', $line, $match);
           if ($ok) {
             break;
           }
         }
 
         if (!$ok) {
           if ($line === null ||
               preg_match('/^(diff --git|commit) /', $line)) {
             // In this case, there are ONLY file mode changes, or this is a
             // pure move. If it's a move, flag these changesets so we can build
             // synthetic changes later, enabling us to show file contents in
             // Differential -- git only gives us a block like this:
             //
             //   diff --git a/README b/READYOU
             //   similarity index 100%
             //   rename from README
             //   rename to READYOU
             //
             // ...i.e., there is no associated diff.
 
             // This allows us to distinguish between property changes only
             // and actual moves. For property changes only, we can't currently
             // build a synthetic diff correctly, so just skip it.
             // TODO: Build synthetic diffs for property changes, too.
             if ($change->getType() != ArcanistDiffChangeType::TYPE_CHANGE) {
               $change->setNeedsSyntheticGitHunks(true);
               if ($move_source) {
                 $move_source->setNeedsSyntheticGitHunks(true);
               }
             }
             return;
           }
           break;
         }
 
         if (!empty($match['oldmode'])) {
           $change->setOldProperty('unix:filemode', $match['oldmode']);
         }
         if (!empty($match['newmode'])) {
           $change->setNewProperty('unix:filemode', $match['newmode']);
         }
 
         if (!empty($match['deleted'])) {
           $change->setType(ArcanistDiffChangeType::TYPE_DELETE);
         }
 
         if (!empty($match['new'])) {
           // If you replace a symlink with a normal file, git renders the change
           // as a "delete" of the symlink plus an "add" of the new file. We
           // prefer to represent this as a change.
           if ($change->getType() == ArcanistDiffChangeType::TYPE_DELETE) {
             $change->setType(ArcanistDiffChangeType::TYPE_CHANGE);
           } else {
             $change->setType(ArcanistDiffChangeType::TYPE_ADD);
           }
         }
 
         if (!empty($match['old'])) {
           $match['old'] = self::unescapeFilename($match['old']);
           $change->setOldPath($match['old']);
         }
 
         if (!empty($match['cur'])) {
           $match['cur'] = self::unescapeFilename($match['cur']);
           $change->setCurrentPath($match['cur']);
         }
 
         if (!empty($match['copy'])) {
           $change->setType(ArcanistDiffChangeType::TYPE_COPY_HERE);
           $old = $this->buildChange($change->getOldPath());
           $type = $old->getType();
 
           if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY) {
             $old->setType(ArcanistDiffChangeType::TYPE_MULTICOPY);
           } else {
             $old->setType(ArcanistDiffChangeType::TYPE_COPY_AWAY);
           }
 
           $old->addAwayPath($change->getCurrentPath());
         }
 
         if (!empty($match['move'])) {
           $change->setType(ArcanistDiffChangeType::TYPE_MOVE_HERE);
           $old = $this->buildChange($change->getOldPath());
           $type = $old->getType();
 
           if ($type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
             // Great, no change.
           } else if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY) {
             $old->setType(ArcanistDiffChangeType::TYPE_MULTICOPY);
           } else if ($type == ArcanistDiffChangeType::TYPE_COPY_AWAY) {
             $old->setType(ArcanistDiffChangeType::TYPE_MULTICOPY);
           } else {
             $old->setType(ArcanistDiffChangeType::TYPE_MOVE_AWAY);
           }
 
           // We'll reference this above.
           $move_source = $old;
 
           $old->addAwayPath($change->getCurrentPath());
         }
 
         $line = $this->nextNonemptyLine();
       } while (true);
     }
 
     $line = $this->getLine();
 
     if ($is_svn) {
       $ok = preg_match('/^=+\s*$/', $line);
       if (!$ok) {
         $this->didFailParse("Expected '=======================' divider line.");
       } else {
         // Adding an empty file in SVN can produce an empty line here.
         $line = $this->nextNonemptyLine();
       }
     } else if ($is_git) {
       $ok = preg_match('/^index .*$/', $line);
       if (!$ok) {
         // TODO: "hg diff -g" diffs ("mercurial git-style diffs") do not include
         // this line, so we can't parse them if we fail on it. Maybe introduce
         // a flag saying "parse this diff using relaxed git-style diff rules"?
 
         // $this->didFailParse("Expected 'index af23f...a98bc' header line.");
       } else {
         // NOTE: In the git case, where this patch is the last change in the
         // file, we may have a final terminal newline. Skip over it so that
         // we'll hit the '$line === null' block below. This is covered by the
         // 'git-empty-file.gitdiff' test case.
         $line = $this->nextNonemptyLine();
       }
     }
 
     // If there are files with only whitespace changes and -b or -w are
     // supplied as command-line flags to `diff', svn and git both produce
     // changes without any body.
     if ($line === null ||
         preg_match(
           '/^(Index:|Property changes on:|diff --git|commit) /',
           $line)) {
       return;
     }
 
     $is_binary_add = preg_match(
       '/^Cannot display: file marked as a binary type\.$/',
       rtrim($line));
     if ($is_binary_add) {
       $this->nextLine(); // Cannot display: file marked as a binary type.
       $this->nextNonemptyLine(); // svn:mime-type = application/octet-stream
       $this->markBinary($change);
       return;
     }
 
     // We can get this in git, or in SVN when a file exists in the repository
     // WITHOUT a binary mime-type and is changed and given a binary mime-type.
     $is_binary_diff = preg_match(
       '/^(Binary files|Files) .* and .* differ$/',
       rtrim($line));
     if ($is_binary_diff) {
       $this->nextNonemptyLine(); // Binary files x and y differ
       $this->markBinary($change);
       return;
     }
 
     // This occurs under "hg diff --git" when a binary file is removed. See
     // test case "hg-binary-delete.hgdiff". (I believe it never occurs under
     // git, which reports the "files X and /dev/null differ" string above. Git
     // can not apply these patches.)
     $is_hg_binary_delete = preg_match(
       '/^Binary file .* has changed$/',
       rtrim($line));
     if ($is_hg_binary_delete) {
       $this->nextNonemptyLine();
       $this->markBinary($change);
       return;
     }
 
     // With "git diff --binary" (not a normal mode, but one users may explicitly
     // invoke and then, e.g., copy-paste into the web console) or "hg diff
     // --git" (normal under hg workflows), we may encounter a literal binary
     // patch.
     $is_git_binary_patch = preg_match(
       '/^GIT binary patch$/',
       rtrim($line));
     if ($is_git_binary_patch) {
       $this->nextLine();
       $this->parseGitBinaryPatch();
       $line = $this->getLine();
       if (preg_match('/^literal/', $line)) {
         // We may have old/new binaries (change) or just a new binary (hg add).
         // If there are two blocks, parse both.
         $this->parseGitBinaryPatch();
       }
       $this->markBinary($change);
       return;
     }
 
     if ($is_git) {
       // "git diff -b" ignores whitespace, but has an empty hunk target
       if (preg_match('@^diff --git .*$@', $line)) {
         $this->nextLine();
         return null;
       }
     }
 
     if ($this->isRCS) {
       // Skip the RCS headers.
       $this->nextLine();
       $this->nextLine();
       $this->nextLine();
     }
 
     $old_file = $this->parseHunkTarget();
     $new_file = $this->parseHunkTarget();
 
     if ($this->isRCS) {
       $change->setCurrentPath($new_file);
     }
 
     $change->setOldPath($old_file);
 
     $this->parseChangeset($change);
   }
 
   private function parseGitBinaryPatch() {
 
     // TODO: We could decode the patches, but it's a giant mess so don't bother
     // for now. We'll pick up the data from the working copy in the common
     // case ("arc diff").
 
     $line = $this->getLine();
     if (!preg_match('/^literal /', $line)) {
       $this->didFailParse("Expected 'literal NNNN' to start git binary patch.");
     }
     do {
       $line = $this->nextLineTrimmed();
       if ($line === '' || $line === null) {
         // Some versions of Mercurial apparently omit the terminal newline,
         // although it's unclear if Git will ever do this. In either case,
         // rely on the base85 check for sanity.
         $this->nextNonemptyLine();
         return;
       } else if (!preg_match('/^[a-zA-Z]/', $line)) {
         $this->didFailParse('Expected base85 line length character (a-zA-Z).');
       }
     } while (true);
   }
 
   protected function parseHunkTarget() {
     $line = $this->getLine();
     $matches = null;
 
     $remainder = '(?:\s*\(.*\))?';
     if ($this->getIsMercurial()) {
       // Something like "Fri Aug 26 01:20:50 2005 -0700", don't bother trying
       // to parse it.
       $remainder = '\t.*';
     } else if ($this->isRCS) {
       $remainder = '\s.*';
     }
 
     $ok = preg_match(
       '@^[-+]{3} (?:[ab]/)?(?P<path>.*?)'.$remainder.'$@',
       $line,
       $matches);
 
     if (!$ok) {
       $this->didFailParse(
         "Expected hunk target '+++ path/to/file.ext (revision N)'.");
     }
 
     $this->nextLine();
     return $matches['path'];
   }
 
   protected function markBinary(ArcanistDiffChange $change) {
     $change->setFileType(ArcanistDiffChangeType::FILE_BINARY);
     return $this;
   }
 
   protected function parseChangeset(ArcanistDiffChange $change) {
     $all_changes = array();
     do {
       $hunk = new ArcanistDiffHunk();
       $line = $this->getLineTrimmed();
       $real = array();
 
       // In the case where only one line is changed, the length is omitted.
       // The final group is for git, which appends a guess at the function
       // context to the diff.
       $matches = null;
       $ok = preg_match(
         '/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: .*?)?$/U',
         $line,
         $matches);
 
       if (!$ok) {
         // It's possible we hit the style of an svn1.7 property change.
         // This is a 4-line Index block, followed by an empty line, followed
         // by a "Property changes on:" section similar to svn1.6.
         if ($line == '') {
           $line = $this->nextNonemptyLine();
           $ok = preg_match('/^Property changes on:/', $line);
           if (!$ok) {
             $this->didFailParse('Confused by empty line');
           }
           $line = $this->nextLine();
           return $this->parsePropertyHunk($change);
         }
         $this->didFailParse("Expected hunk header '@@ -NN,NN +NN,NN @@'.");
       }
 
       $hunk->setOldOffset($matches[1]);
       $hunk->setNewOffset($matches[3]);
 
       // Cover for the cases where length wasn't present (implying one line).
       $old_len = idx($matches, 2);
       if (!strlen($old_len)) {
         $old_len = 1;
       }
       $new_len = idx($matches, 4);
       if (!strlen($new_len)) {
         $new_len = 1;
       }
 
       $hunk->setOldLength($old_len);
       $hunk->setNewLength($new_len);
 
       $add = 0;
       $del = 0;
 
       $hit_next_hunk = false;
       while ((($line = $this->nextLine()) !== null)) {
         if (strlen(rtrim($line, "\r\n"))) {
           $char = $line[0];
         } else {
           // Normally, we do not encouter empty lines in diffs, because
           // unchanged lines have an initial space. However, in Git, with
           // the option `diff.suppress-blank-empty` set, unchanged blank lines
           // emit as completely empty. If we encounter a completely empty line,
           // treat it as a ' ' (i.e., unchanged empty line) line.
           $char = ' ';
         }
         switch ($char) {
           case '\\':
             if (!preg_match('@\\ No newline at end of file@', $line)) {
               $this->didFailParse(
                 "Expected '\ No newline at end of file'.");
             }
             if ($new_len) {
               $real[] = $line;
               $hunk->setIsMissingOldNewline(true);
             } else {
               $real[] = $line;
               $hunk->setIsMissingNewNewline(true);
             }
             if (!$new_len) {
               break 2;
             }
             break;
           case '+':
             ++$add;
             --$new_len;
             $real[] = $line;
             break;
           case '-':
             if (!$old_len) {
               // In this case, we've hit "---" from a new file. So don't
               // advance the line cursor.
               $hit_next_hunk = true;
               break 2;
             }
             ++$del;
             --$old_len;
             $real[] = $line;
             break;
           case ' ':
             if (!$old_len && !$new_len) {
               break 2;
             }
             --$old_len;
             --$new_len;
             $real[] = $line;
             break;
           default:
             // We hit something, likely another hunk.
             $hit_next_hunk = true;
             break 2;
         }
       }
 
       if ($old_len || $new_len) {
         $this->didFailParse('Found the wrong number of hunk lines.');
       }
 
       $corpus = implode('', $real);
 
       $is_binary = false;
       if ($this->detectBinaryFiles) {
         $is_binary = !phutil_is_utf8($corpus);
         $try_encoding = $this->tryEncoding;
 
         if ($is_binary && $try_encoding) {
           $is_binary = ArcanistDiffUtils::isHeuristicBinaryFile($corpus);
           if (!$is_binary) {
             $corpus = phutil_utf8_convert($corpus, 'UTF-8', $try_encoding);
             if (!phutil_is_utf8($corpus)) {
               throw new Exception(
                 "Failed to convert a hunk from '{$try_encoding}' to UTF-8. ".
                 "Check that the specified encoding is correct.");
             }
           }
         }
 
       }
 
       if ($is_binary) {
         // SVN happily treats binary files which aren't marked with the right
         // mime type as text files. Detect that junk here and mark the file
         // binary. We'll catch stuff with unicode too, but that's verboten
         // anyway. If there are too many false positives with this we might
         // need to make it threshold-triggered instead of triggering on any
         // unprintable byte.
         $change->setFileType(ArcanistDiffChangeType::FILE_BINARY);
       } else {
         $hunk->setCorpus($corpus);
         $hunk->setAddLines($add);
         $hunk->setDelLines($del);
         $change->addHunk($hunk);
       }
 
       if (!$hit_next_hunk) {
         $line = $this->nextNonemptyLine();
       }
 
     } while (preg_match('/^@@ /', $line));
   }
 
   protected function buildChange($path = null) {
     $change = null;
     if ($path !== null) {
       if (!empty($this->changes[$path])) {
         return $this->changes[$path];
       }
     }
 
     if ($this->forcePath) {
       return $this->changes[$this->forcePath];
     }
 
     $change = new ArcanistDiffChange();
     if ($path !== null) {
       $change->setCurrentPath($path);
       $this->changes[$path] = $change;
     } else {
       $this->changes[] = $change;
     }
 
     return $change;
   }
 
   protected function didStartParse($text) {
     $this->rawDiff = $text;
 
     // Eat leading whitespace. This may happen if the first change in the diff
     // is an SVN property change.
     $text = ltrim($text);
 
     // Try to strip ANSI color codes from colorized diffs. ANSI color codes
     // might be present in two cases:
     //
     //   - You piped a colorized diff into 'arc --raw' or similar (normally
     //     we're able to disable colorization on diffs we control the generation
     //     of).
     //   - You're diffing a file which actually contains ANSI color codes.
     //
     // The former is vastly more likely, but we try to distinguish between the
     // two cases by testing for a color code at the beginning of a line. If
     // we find one, we know it's a colorized diff (since the beginning of the
     // line should be "+", "-" or " " if the code is in the diff text).
     //
     // While it's possible a diff might be colorized and fail this test, it's
     // unlikely, and it covers hg's color extension which seems to be the most
     // stubborn about colorizing text despite stdout not being a TTY.
     //
     // We might incorrectly strip color codes from a colorized diff of a text
     // file with color codes inside it, but this case is stupid and pathological
     // and you've dug your own grave.
 
     $ansi_color_pattern = '\x1B\[[\d;]*m';
     if (preg_match('/^'.$ansi_color_pattern.'/m', $text)) {
       $text = preg_replace('/'.$ansi_color_pattern.'/', '', $text);
     }
 
     $this->text = phutil_split_lines($text);
     $this->line = 0;
   }
 
   protected function getLine() {
     if ($this->text === null) {
       throw new Exception('Not parsing!');
     }
     if (isset($this->text[$this->line])) {
       return $this->text[$this->line];
     }
     return null;
   }
 
   protected function getLineTrimmed() {
     $line = $this->getLine();
     if ($line !== null) {
       $line = trim($line, "\r\n");
     }
     return $line;
   }
 
   protected function nextLine() {
     $this->line++;
     return $this->getLine();
   }
 
   protected function nextLineTrimmed() {
     $line = $this->nextLine();
     if ($line !== null) {
       $line = trim($line, "\r\n");
     }
     return $line;
   }
 
   protected function nextNonemptyLine() {
     while (($line = $this->nextLine()) !== null) {
       if (strlen(trim($line)) !== 0) {
         break;
       }
     }
     return $this->getLine();
   }
 
   protected function nextLineThatLooksLikeDiffStart() {
     while (($line = $this->nextLine()) !== null) {
       if (preg_match('/^\s*diff\s+-(?:r|-git)/', $line)) {
         break;
       }
     }
     return $this->getLine();
   }
 
   protected function saveLine() {
     $this->lineSaved = $this->line;
   }
 
   protected function restoreLine() {
     $this->line = $this->lineSaved;
   }
 
   protected function isFirstNonEmptyLine() {
     $len = count($this->text);
     for ($ii = 0; $ii < $len; $ii++) {
       $line = $this->text[$ii];
 
       if (!strlen(trim($line))) {
         // This line is empty, skip it.
         continue;
       }
 
       if (preg_match('/^#/', $line)) {
         // This line is a comment, skip it.
         continue;
       }
 
       return ($ii == $this->line);
     }
 
     // Entire file is empty.
     return false;
   }
 
   protected function didFinishParse() {
     $this->text = null;
   }
 
   public function setWriteDiffOnFailure($write) {
     $this->writeDiffOnFailure = $write;
     return $this;
   }
 
   protected function didFailParse($message) {
     $context = 5;
     $min = max(0, $this->line - $context);
     $max = min($this->line + $context, count($this->text) - 1);
 
     $context = '';
     for ($ii = $min; $ii <= $max; $ii++) {
       $context .= sprintf(
         '%8.8s %6.6s   %s',
         ($ii == $this->line) ? '>>>  ' : '',
         $ii + 1,
         $this->text[$ii]);
     }
 
     $out = array();
     $out[] = "Diff Parse Exception: {$message}";
 
     if ($this->writeDiffOnFailure) {
       $temp = new TempFile();
       $temp->setPreserveFile(true);
 
       Filesystem::writeFile($temp, $this->rawDiff);
       $out[] = 'Raw input file was written to: '.(string)$temp;
     }
 
     $out[] = $context;
     $out = implode("\n\n", $out);
 
     throw new Exception($out);
   }
 
   /**
    * Unescape escaped filenames, e.g. from "git diff".
    */
   private static function unescapeFilename($name) {
     if (preg_match('/^".+"$/', $name)) {
       return stripcslashes(substr($name, 1, -1));
     } else {
       return $name;
     }
   }
 
   private function loadSyntheticData() {
     if (!$this->changes) {
       return;
     }
 
     $repository_api = $this->repositoryAPI;
     if (!$repository_api) {
       return;
     }
 
     $imagechanges = array();
 
     $changes = $this->changes;
     foreach ($changes as $change) {
       $path = $change->getCurrentPath();
 
       // Certain types of changes (moves and copies) don't contain change data
       // when expressed in raw "git diff" form. Augment any such diffs with
       // textual data.
       if ($change->getNeedsSyntheticGitHunks() &&
           ($repository_api instanceof ArcanistGitAPI)) {
         $diff = $repository_api->getRawDiffText($path, $moves = false);
 
         // NOTE: We're reusing the parser and it doesn't reset change state
         // between parses because there's an oddball SVN workflow in Phabricator
         // which relies on being able to inject changes.
         // TODO: Fix this.
         $parser = clone $this;
         $parser->setChanges(array());
         $raw_changes = $parser->parseDiff($diff);
 
         foreach ($raw_changes as $raw_change) {
           if ($raw_change->getCurrentPath() == $path) {
             $change->setFileType($raw_change->getFileType());
             foreach ($raw_change->getHunks() as $hunk) {
               // Git thinks that this file has been added. But we know that it
               // has been moved or copied without a change.
               $hunk->setCorpus(
                 preg_replace('/^\+/m', ' ', $hunk->getCorpus()));
               $change->addHunk($hunk);
             }
             break;
           }
         }
 
         $change->setNeedsSyntheticGitHunks(false);
       }
 
       if ($change->getFileType() != ArcanistDiffChangeType::FILE_BINARY &&
           $change->getFileType() != ArcanistDiffChangeType::FILE_IMAGE) {
         continue;
       }
 
       $imagechanges[$path] = $change;
     }
 
     // Fetch the actual file contents in batches so repositories
     // that have slow random file accesses (i.e. mercurial) can
     // optimize the retrieval.
     $paths = array_keys($imagechanges);
 
     $filedata = $repository_api->getBulkOriginalFileData($paths);
     foreach ($filedata as $path => $data) {
       $imagechanges[$path]->setOriginalFileData($data);
     }
 
     $filedata = $repository_api->getBulkCurrentFileData($paths);
     foreach ($filedata as $path => $data) {
       $imagechanges[$path]->setCurrentFileData($data);
     }
 
     $this->changes = $changes;
   }
 
 
   /**
    * Strip prefixes off paths from `git diff`. By default git uses a/ and b/,
    * but you can set `diff.mnemonicprefix` to get a different set of prefixes,
    * or use `--no-prefix`, `--src-prefix` or `--dst-prefix` to set these to
    * other arbitrary values.
    *
    * We strip the default and mnemonic prefixes, and trust the user knows what
    * they're doing in the other cases.
    *
    * @param   string Path to strip.
    * @return  string Stripped path.
    */
   public static function stripGitPathPrefix($path) {
 
     static $regex;
     if ($regex === null) {
       $prefixes = array(
         // These are the defaults.
         'a/',
         'b/',
 
         // These show up when you set "diff.mnemonicprefix".
         'i/',
         'c/',
         'w/',
         'o/',
         '1/',
         '2/',
       );
 
       foreach ($prefixes as $key => $prefix) {
         $prefixes[$key] = preg_quote($prefix, '@');
       }
       $regex = '@^('.implode('|', $prefixes).')@S';
     }
 
     return preg_replace($regex, '', $path);
   }
 
 
   /**
    * Split the paths on a "diff --git" line into old and new paths. This
    * is difficult because they may be ambiguous if the files contain spaces.
    *
    * @param string Text from a diff line after "diff --git ".
    * @return pair<string, string> Old and new paths.
    */
   public static function splitGitDiffPaths($paths) {
     $matches = null;
     $paths = rtrim($paths, "\r\n");
 
     $patterns = array(
       // Try quoted paths, used for unicode filenames or filenames with quotes.
       '@^(?P<old>"(?:\\\\.|[^"\\\\]+)+") (?P<new>"(?:\\\\.|[^"\\\\]+)+")$@',
 
       // Try paths without spaces.
       '@^(?P<old>[^ ]+) (?P<new>[^ ]+)$@',
 
       // Try paths with well-known prefixes.
       '@^(?P<old>[abicwo12]/.*) (?P<new>[abicwo12]/.*)$@',
 
       // Try the exact same string twice in a row separated by a space.
       // This can hit a false positive for moves from files like "old file old"
       // to "file", but such a case combined with custom diff prefixes is
       // incredibly obscure.
       '@^(?P<old>.*) (?P<new>\\1)$@',
     );
 
     foreach ($patterns as $pattern) {
       if (preg_match($pattern, $paths, $matches)) {
         break;
       }
     }
 
     if (!$matches) {
       throw new Exception(
         "Input diff contains ambiguous line 'diff --git {$paths}'. This line ".
         "is ambiguous because there are spaces in the file names, so the ".
         "parser can not determine where the file names begin and end. To ".
         "resolve this ambiguity, use standard prefixes ('a/' and 'b/') when ".
         "generating diffs.");
     }
 
     $old = $matches['old'];
     $old = self::unescapeFilename($old);
     $old = self::stripGitPathPrefix($old);
 
     $new = $matches['new'];
     $new = self::unescapeFilename($new);
     $new = self::stripGitPathPrefix($new);
 
     return array($old, $new);
   }
 
 
   /**
    * Strip the header and footer off a `git-format-patch` diff.
    *
    * Returns a parseable normal diff and a textual commit message.
    */
   private function stripGitFormatPatch($diff) {
-
     // We can parse this by splitting it into two pieces over and over again
     // along different section dividers:
     //
     //   1. Mail headers.
     //   2. ("\n\n")
     //   3. Mail body.
     //   4. ("---")
     //   5. Diff stat section.
     //   6. ("\n\n")
     //   7. Actual diff body.
     //   8. ("--")
     //   9. Patch footer.
 
     list($head, $tail) = preg_split('/^---$/m', $diff, 2);
     list($mail_headers, $mail_body) = explode("\n\n", $head, 2);
     list($body, $foot) = preg_split('/^-- ?$/m', $tail, 2);
     list($stat, $diff) = explode("\n\n", $body, 2);
 
     // Rebuild the commit message by putting the subject line back on top of it,
     // if we can find one.
     $matches = null;
     $pattern = '/^Subject: (?:\[PATCH\] )?(.*)$/mi';
     if (preg_match($pattern, $mail_headers, $matches)) {
       $mail_body = $matches[1]."\n\n".$mail_body;
       $mail_body = rtrim($mail_body);
     }
 
     return array($mail_body, $diff);
   }
 
 }
diff --git a/src/parser/__tests__/ArcanistDiffParserTestCase.php b/src/parser/__tests__/ArcanistDiffParserTestCase.php
index 214b81bc..965468da 100644
--- a/src/parser/__tests__/ArcanistDiffParserTestCase.php
+++ b/src/parser/__tests__/ArcanistDiffParserTestCase.php
@@ -1,676 +1,674 @@
 <?php
 
 /**
  * Test cases for @{class:ArcanistDiffParser}.
- *
- * @group testcase
  */
 final class ArcanistDiffParserTestCase extends ArcanistTestCase {
 
   public function testParser() {
     $root = dirname(__FILE__).'/diff/';
     foreach (Filesystem::listDirectory($root, $hidden = false) as $file) {
       $this->parseDiff($root.$file);
     }
   }
 
   private function parseDiff($diff_file) {
     $contents = Filesystem::readFile($diff_file);
     $file = basename($diff_file);
 
     $parser = new ArcanistDiffParser();
     $changes = $parser->parseDiff($contents);
 
     switch ($file) {
       case 'colorized.hggitdiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'basic-missing-both-newlines-plus.udiff':
       case 'basic-missing-both-newlines.udiff':
       case 'basic-missing-new-newline-plus.udiff':
       case 'basic-missing-new-newline.udiff':
       case 'basic-missing-old-newline-plus.udiff':
       case 'basic-missing-old-newline.udiff':
         $expect_old = strpos($file, '-old-') || strpos($file, '-both-');
         $expect_new = strpos($file, '-new-') || strpos($file, '-both-');
         $expect_two = strpos($file, '-plus');
 
         $this->assertEqual(count($changes), $expect_two ? 2 : 1);
         $change = reset($changes);
         $this->assertTrue($change !== null);
 
         $hunks = $change->getHunks();
         $this->assertEqual(1, count($hunks));
 
         $hunk = reset($hunks);
         $this->assertEqual((bool)$expect_old, $hunk->getIsMissingOldNewline());
         $this->assertEqual((bool)$expect_new, $hunk->getIsMissingNewNewline());
         break;
       case 'basic-binary.udiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         break;
       case 'basic-multi-hunk.udiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $hunks = $change->getHunks();
         $this->assertEqual(4, count($hunks));
         $this->assertEqual('right', $change->getCurrentPath());
         $this->assertEqual('left', $change->getOldPath());
         break;
       case 'basic-multi-hunk-content.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $hunks = $change->getHunks();
         $this->assertEqual(2, count($hunks));
 
         $there_is_a_literal_trailing_space_here = ' ';
 
         $corpus_0 = <<<EOCORPUS
  asdfasdf
 +% quack
  %
 -%
  %%
  %%
  %%%
 
 EOCORPUS;
         $corpus_1 = <<<EOCORPUS
  %%%%%
  %%%%%
 {$there_is_a_literal_trailing_space_here}
 -!
 +! quack
 
 EOCORPUS;
         $this->assertEqual(
           $corpus_0,
           $hunks[0]->getCorpus());
         $this->assertEqual(
           $corpus_1,
           $hunks[1]->getCorpus());
         break;
       case 'svn-ignore-whitespace-only.svndiff':
         $this->assertEqual(2, count($changes));
         $hunks = reset($changes)->getHunks();
         $this->assertEqual(0, count($hunks));
         break;
       case 'svn-property-add.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $hunks = reset($changes)->getHunks();
         $this->assertEqual(1, count($hunks));
         $this->assertEqual(
           array(
             'duck' => 'quack',
           ),
           $change->getNewProperties());
         break;
       case 'svn-property-modify.svndiff':
         $this->assertEqual(2, count($changes));
 
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           array(
             'svn:ignore' => '*.phpz',
           ),
           $change->getOldProperties());
         $this->assertEqual(
           array(
             'svn:ignore' => '*.php',
           ),
           $change->getNewProperties());
 
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           array(
             'svn:special' => '*',
           ),
           $change->getOldProperties());
         $this->assertEqual(
           array(
             'svn:special' => 'moo',
           ),
           $change->getNewProperties());
         break;
       case 'svn-property-delete.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
 
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           $change->getOldProperties(),
           array(
             'svn:special' => '*',
           ));
         $this->assertEqual(
           array(
           ),
           $change->getNewProperties());
         break;
       case 'svn-property-merged.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
 
         $this->assertEqual(count($change->getHunks()), 0);
 
         $this->assertEqual(
           $change->getOldProperties(),
           array());
         $this->assertEqual(
           $change->getNewProperties(),
           array());
         break;
       case 'svn-property-merge.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
 
         $this->assertEqual(count($change->getHunks()), 0);
         $this->assertEqual(
           $change->getOldProperties(),
           array(
           ));
         $this->assertEqual(
           $change->getNewProperties(),
           array(
             'svn:mergeinfo' => <<<EOTEXT
 Merged /tfb/branches/internmove/www/html/js/help/UIFaq.js:r83462-126155
 Merged /tfb/branches/ads-create-v3/www/html/js/help/UIFaq.js:r140558-142418
 EOTEXT
           ));
         break;
       case 'svn-property-older-than-1.5.svndiff':
         // In SVN 1.5, the format for property diffs changed to use the words
         // "Added", "Deleted" and "Modified" instead of "Name". This is an old
         // property change diff which uses "Name".
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
 
         $this->assertEqual(count($change->getHunks()), 0);
         $this->assertEqual(
           $change->getOldProperties(),
           array(
           ));
         $this->assertEqual(
           $change->getNewProperties(),
           array(
             'svn:executable' => '*',
           ));
         break;
       case 'svn-binary-add.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           array(
             'svn:mime-type' => 'application/octet-stream',
           ),
           $change->getNewProperties());
         break;
       case 'svn-binary-diff.svndiff':
       case 'svn-binary-diff-freebsd.svndiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         $this->assertEqual(count($change->getHunks()), 0);
         break;
       case 'git-delete-file.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $change->getType());
         $this->assertEqual(
           'scripts/intern/test/testfile2',
           $change->getCurrentPath());
         $this->assertEqual(1, count($change->getHunks()));
         break;
       case 'git-binary-change.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         $this->assertEqual(0, count($change->getHunks()));
         break;
       case 'git-filemode-change.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(1, count($change->getHunks()));
         $this->assertEqual(
           array(
             'unix:filemode' => '100644',
           ),
           $change->getOldProperties());
         $this->assertEqual(
           array(
             'unix:filemode' => '100755',
           ),
           $change->getNewProperties());
         break;
       case 'git-filemode-change-only.gitdiff':
         $this->assertEqual(count($changes), 2);
         $change = reset($changes);
         $this->assertEqual(count($change->getHunks()), 0);
         $this->assertEqual(
           array(
             'unix:filemode' => '100644',
           ),
           $change->getOldProperties());
         $this->assertEqual(
           array(
             'unix:filemode' => '100755',
           ),
           $change->getNewProperties());
         break;
       case 'svn-empty-file.svndiff':
         $this->assertEqual(2, count($changes));
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         break;
       case 'git-ignore-whitespace-only.gitdiff':
         $this->assertEqual(count($changes), 2);
 
         $change = array_shift($changes);
         $this->assertEqual(count($change->getHunks()), 0);
         $this->assertEqual(
           $change->getOldPath(),
           'scripts/intern/test/testfile2');
         $this->assertEqual(
           $change->getCurrentPath(),
           'scripts/intern/test/testfile2');
 
         $change = array_shift($changes);
         $this->assertEqual(count($change->getHunks()), 1);
         $this->assertEqual(
           $change->getOldPath(),
           'scripts/intern/test/testfile3');
         $this->assertEqual(
           $change->getCurrentPath(),
           'scripts/intern/test/testfile3');
         break;
       case 'git-move.gitdiff':
       case 'git-move-edit.gitdiff':
       case 'git-move-plus.gitdiff':
 
         $extra_changeset = (bool)strpos($file, '-plus');
         $has_hunk = (bool)strpos($file, '-edit');
 
         $this->assertEqual($extra_changeset ? 3 : 2, count($changes));
 
         $change = array_shift($changes);
         $this->assertEqual($has_hunk ? 1 : 0,
                           count($change->getHunks()));
         $this->assertEqual(
           $change->getType(),
           ArcanistDiffChangeType::TYPE_MOVE_HERE);
 
         $target = $change;
 
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $change->getType());
 
         $this->assertEqual(
           $change->getCurrentPath(),
           $target->getOldPath());
         $this->assertTrue(
           in_array($target->getCurrentPath(), $change->getAwayPaths()));
         break;
       case 'git-merge-header.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MESSAGE,
           $change->getType());
         $this->assertEqual(
           '501f6d519703458471dbea6284ec5f49d1408598',
           $change->getCommitHash());
         break;
       case 'git-new-file.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $change->getType());
         break;
       case 'git-copy.gitdiff':
         $this->assertEqual(2, count($changes));
 
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $change->getType());
         $this->assertEqual(
           'flib/intern/widgets/ui/UIWidgetRSSBox.php',
           $change->getCurrentPath());
 
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_AWAY,
           $change->getType());
         $this->assertEqual(
           'lib/display/intern/ui/widget/UIWidgetRSSBox.php',
           $change->getCurrentPath());
 
         break;
       case 'git-copy-plus.gitdiff':
         $this->assertEqual(2, count($changes));
 
         $change = array_shift($changes);
         $this->assertEqual(3, count($change->getHunks()));
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $change->getType());
         $this->assertEqual(
           'flib/intern/widgets/ui/UIWidgetGraphConnect.php',
           $change->getCurrentPath());
 
         $change = array_shift($changes);
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_AWAY,
           $change->getType());
         $this->assertEqual(
           'lib/display/intern/ui/widget/UIWidgetLunchtime.php',
           $change->getCurrentPath());
         break;
       case 'svn-property-multiline.svndiff':
         $this->assertEqual(1, count($changes));
         $change = array_shift($changes);
 
         $this->assertEqual(0, count($change->getHunks()));
         $this->assertEqual(
           array(
             'svn:ignore' => 'tags',
           ),
           $change->getOldProperties());
         $this->assertEqual(
           array(
             'svn:ignore' => "tags\nasdf\nlol\nwhat",
           ),
           $change->getNewProperties());
         break;
       case 'git-empty-files.gitdiff':
         $this->assertEqual(2, count($changes));
         while ($change = array_shift($changes)) {
           $this->assertEqual(0, count($change->getHunks()));
         }
         break;
       case 'git-mnemonicprefix.gitdiff':
         // Check parsing of diffs created with `diff.mnemonicprefix`
         // configuration option set to `true`.
         $this->assertEqual(1, count($changes));
         $this->assertEqual(1, count(reset($changes)->getHunks()));
         break;
       case 'git-commit.gitdiff':
       case 'git-commit-logdecorate.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MESSAGE,
           $change->getType());
         $this->assertEqual(
           '76e2f1339c298c748aa0b52030799ed202a6537b',
           $change->getCommitHash());
         $this->assertEqual(
           <<<EOTEXT
 
 Deprecating UIActionButton (Part 1)
 
 Summary: Replaces calls to UIActionButton with <ui:button>.  I tested most
          of these calls, but there were some that I didn't know how to
          reach, so if you are one of the owners of this code, please test
          your feature in my sandbox: www.ngao.devrs013.facebook.com
 
          @brosenthal, I removed some logic that was setting a disabled state
          on a UIActionButton, which is actually a no-op.
 
 Reviewed By: brosenthal
 
 Other Commenters: sparker, egiovanola
 
 Test Plan: www.ngao.devrs013.facebook.com
 
            Explicitly tested:
            * ads creation flow (add keyword)
            * ads manager (conversion tracking)
            * help center (create a discussion)
            * new user wizard (next step button)
 
 Revert: OK
 
 DiffCamp Revision: 94064
 
 git-svn-id: svn+ssh://tubbs/svnroot/tfb/trunk/www@223593 2c7ba8d8
 EOTEXT
           , $change->getMetadata('message'));
         break;
       case 'git-binary.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $change->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         break;
       case 'git-odd-filename.gitdiff':
         $this->assertEqual(2, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           'old/'."\342\210\206".'.jpg',
           $change->getOldPath());
         $this->assertEqual(
           'new/'."\342\210\206".'.jpg',
           $change->getCurrentPath());
         break;
       case 'hg-binary-change.hgdiff':
       case 'hg-solo-binary-change.hgdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $change->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         break;
       case 'hg-binary-delete.hgdiff':
         $this->assertEqual(1, count($changes));
         $change = reset($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $change->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $change->getFileType());
         break;
       case 'git-replace-symlink.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = array_shift($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $change->getType());
         break;
       case 'svn-1.7-property-added.svndiff':
         $this->assertEqual(1, count($changes));
         $change = head($changes);
         $new_properties = $change->getNewProperties();
         $this->assertEqual(2, count($new_properties));
         $this->assertEqual('*', idx($new_properties, 'svn:executable'));
         $this->assertEqual('text/html', idx($new_properties, 'svn:mime-type'));
         break;
       case 'hg-diff-range.hgdiff':
         $this->assertEqual(1, count($changes));
         $change = array_shift($changes);
         $this->assertEqual(
           'Test.java',
           $change->getOldPath());
         $this->assertEqual(
           'Test.java',
           $change->getCurrentPath());
         break;
       case 'hg-patch.hgdiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'hg-patch-git.hgdiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'custom-prefixes.gitdiff':
         $this->assertEqual(1, count($changes));
         $change = head($changes);
         $this->assertEqual(
           'dst/file',
           $change->getCurrentPath());
         break;
       case 'more-newlines.svndiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'suppress-blank-empty.gitdiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'svn-property-windows.svndiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'rcs-addline.rcsdiff':
         $this->assertEqual(1, count($changes));
         $change = array_shift($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $change->getType());
         break;
       case 'rcs-deleteline.rcsdiff':
         $this->assertEqual(1, count($changes));
         $change = array_shift($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $change->getType());
         break;
       case 'comment.svndiff':
         $this->assertEqual(1, count($changes));
         $change = array_shift($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $change->getType());
         break;
       case 'svnlook-basics.svndiff':
       case 'svnlook-add.svndiff':
       case 'svnlook-delete.svndiff':
       case 'svnlook-copied.svndiff':
         $this->assertEqual(1, count($changes));
         break;
       case 'git-format-patch.gitdiff':
         $this->assertEqual(2, count($changes));
 
         $change = array_shift($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MESSAGE,
           $change->getType());
         $this->assertEqual('WIP', $change->getMetadata('message'));
 
         $change = array_shift($changes);
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $change->getType());
         break;
       default:
         throw new Exception("No test block for diff file {$diff_file}.");
         break;
     }
   }
 
   public function testGitPrefixStripping() {
     static $tests = array(
       'a/file.c'    => 'file.c',
       'b/file.c'    => 'file.c',
       'i/file.c'    => 'file.c',
       'c/file.c'    => 'file.c',
       'w/file.c'    => 'file.c',
       'o/file.c'    => 'file.c',
       '1/file.c'    => 'file.c',
       '2/file.c'    => 'file.c',
       'src/file.c'  => 'src/file.c',
       'file.c'      => 'file.c',
     );
 
     foreach ($tests as $input => $expect) {
       $this->assertEqual(
         $expect,
         ArcanistDiffParser::stripGitPathPrefix($input),
         "Strip git prefix from '{$input}'.");
     }
   }
 
   public function testGitPathSplitting() {
     static $tests = array(
       'a/old.c b/new.c'       => array('old.c', 'new.c'),
       "a/old.c b/new.c\n"     => array('old.c', 'new.c'),
       "a/old.c b/new.c\r\n"   => array('old.c', 'new.c'),
       'old.c new.c'           => array('old.c', 'new.c'),
       '1/old.c 2/new.c'       => array('old.c', 'new.c'),
       '"a/\\"quotes1\\"" "b/\\"quotes2\\""' => array(
         '"quotes1"',
         '"quotes2"',
       ),
       '"a/\\"quotes and spaces1\\"" "b/\\"quotes and spaces2\\""' => array(
         '"quotes and spaces1"',
         '"quotes and spaces2"',
       ),
       '"a/\\342\\230\\2031" "b/\\342\\230\\2032"' => array(
         "\xE2\x98\x831",
         "\xE2\x98\x832",
       ),
       'a/Core Data/old.c b/Core Data/new.c' => array(
         'Core Data/old.c',
         'Core Data/new.c',
       ),
       'some file with spaces.c some file with spaces.c' => array(
         'some file with spaces.c',
         'some file with spaces.c',
       ),
     );
 
     foreach ($tests as $input => $expect) {
       $result = ArcanistDiffParser::splitGitDiffPaths($input);
       $this->assertEqual(
         $expect,
         $result,
         "Split: {$input}");
     }
 
 
     static $ambiguous = array(
       'old file with spaces.c new file with spaces.c',
     );
 
     foreach ($ambiguous as $input) {
       $caught = null;
       try {
         ArcanistDiffParser::splitGitDiffPaths($input);
       } catch (Exception $ex) {
         $caught = $ex;
       }
       $this->assertTrue(
         ($caught instanceof Exception),
         "Ambiguous: {$input}");
     }
   }
 
 }
diff --git a/src/parser/diff/ArcanistDiffChange.php b/src/parser/diff/ArcanistDiffChange.php
index ec9762b3..3b8c04fa 100644
--- a/src/parser/diff/ArcanistDiffChange.php
+++ b/src/parser/diff/ArcanistDiffChange.php
@@ -1,313 +1,311 @@
 <?php
 
 /**
  * Represents a change to an individual path.
- *
- * @group diff
  */
 final class ArcanistDiffChange {
 
   protected $metadata = array();
 
   protected $oldPath;
   protected $currentPath;
   protected $awayPaths = array();
 
   protected $oldProperties = array();
   protected $newProperties = array();
 
   protected $commitHash;
   protected $type = ArcanistDiffChangeType::TYPE_CHANGE;
   protected $fileType = ArcanistDiffChangeType::FILE_TEXT;
 
   protected $hunks = array();
 
   private $needsSyntheticGitHunks;
 
   private $currentFileData;
   private $originalFileData;
 
   public function setOriginalFileData($original_file_data) {
     $this->originalFileData = $original_file_data;
     return $this;
   }
 
   public function getOriginalFileData() {
     return $this->originalFileData;
   }
 
   public function setCurrentFileData($current_file_data) {
     $this->currentFileData = $current_file_data;
     return $this;
   }
 
   public function getCurrentFileData() {
     return $this->currentFileData;
   }
 
   public function toDictionary() {
     $hunks = array();
     foreach ($this->hunks as $hunk) {
       $hunks[] = $hunk->toDictionary();
     }
 
     return array(
       'metadata'      => $this->metadata,
       'oldPath'       => $this->oldPath,
       'currentPath'   => $this->currentPath,
       'awayPaths'     => $this->awayPaths,
       'oldProperties' => $this->oldProperties,
       'newProperties' => $this->newProperties,
       'type'          => $this->type,
       'fileType'      => $this->fileType,
       'commitHash'    => $this->commitHash,
       'hunks'         => $hunks,
     );
   }
 
   public static function newFromDictionary(array $dict) {
     $hunks = array();
     foreach ($dict['hunks'] as $hunk) {
       $hunks[] = ArcanistDiffHunk::newFromDictionary($hunk);
     }
 
     $obj = new ArcanistDiffChange();
     $obj->metadata = $dict['metadata'];
     $obj->oldPath = $dict['oldPath'];
     $obj->currentPath = $dict['currentPath'];
     // TODO: The backend is shipping down some bogus data, e.g. diff 199453.
     // Should probably clean this up.
     $obj->awayPaths     = nonempty($dict['awayPaths'],     array());
     $obj->oldProperties = nonempty($dict['oldProperties'], array());
     $obj->newProperties = nonempty($dict['newProperties'], array());
     $obj->type = $dict['type'];
     $obj->fileType = $dict['fileType'];
     $obj->commitHash = $dict['commitHash'];
     $obj->hunks = $hunks;
 
     return $obj;
   }
 
   public static function newFromConduit(array $dicts) {
     $changes = array();
     foreach ($dicts as $dict) {
       $changes[] = self::newFromDictionary($dict);
     }
     return $changes;
   }
 
   public function getChangedLines($type) {
     $lines = array();
     foreach ($this->hunks as $hunk) {
       $lines += $hunk->getChangedLines($type);
     }
     return $lines;
   }
 
   public function getAllMetadata() {
     return $this->metadata;
   }
 
   public function setMetadata($key, $value) {
     $this->metadata[$key] = $value;
     return $this;
   }
 
   public function getMetadata($key) {
     return idx($this->metadata, $key);
   }
 
   public function setCommitHash($hash) {
     $this->commitHash = $hash;
     return $this;
   }
 
   public function getCommitHash() {
     return $this->commitHash;
   }
 
   public function addAwayPath($path) {
     $this->awayPaths[] = $path;
     return $this;
   }
 
   public function getAwayPaths() {
     return $this->awayPaths;
   }
 
   public function setFileType($type) {
     $this->fileType = $type;
     return $this;
   }
 
   public function getFileType() {
     return $this->fileType;
   }
 
   public function setType($type) {
     $this->type = $type;
     return $this;
   }
 
   public function getType() {
     return $this->type;
   }
 
   public function setOldProperty($key, $value) {
     $this->oldProperties[$key] = $value;
     return $this;
   }
 
   public function setNewProperty($key, $value) {
     $this->newProperties[$key] = $value;
     return $this;
   }
 
   public function getOldProperties() {
     return $this->oldProperties;
   }
 
   public function getNewProperties() {
     return $this->newProperties;
   }
 
   public function setCurrentPath($path) {
     $this->currentPath = $this->filterPath($path);
     return $this;
   }
 
   public function getCurrentPath() {
     return $this->currentPath;
   }
 
   public function setOldPath($path) {
     $this->oldPath = $this->filterPath($path);
     return $this;
   }
 
   public function getOldPath() {
     return $this->oldPath;
   }
 
   public function addHunk(ArcanistDiffHunk $hunk) {
     $this->hunks[] = $hunk;
     return $this;
   }
 
   public function getHunks() {
     return $this->hunks;
   }
 
   /**
    * @return array $old => array($new, )
    */
   public function buildLineMap() {
     $line_map = array();
     $old = 1;
     $new = 1;
     foreach ($this->getHunks() as $hunk) {
       for ($n = $old; $n < $hunk->getOldOffset(); $n++) {
         $line_map[$n] = array($n + $new - $old);
       }
       $old = $hunk->getOldOffset();
       $new = $hunk->getNewOffset();
       $olds = array();
       $news = array();
       $lines = explode("\n", $hunk->getCorpus());
       foreach ($lines as $line) {
         $type = substr($line, 0, 1);
         if ($type == '-' || $type == ' ') {
           $olds[] = $old;
           $old++;
         }
         if ($type == '+' || $type == ' ') {
           $news[] = $new;
           $new++;
         }
         if ($type == ' ' || $type == '') {
           $line_map += array_fill_keys($olds, $news);
           $olds = array();
           $news = array();
         }
       }
     }
     return $line_map;
   }
 
   public function convertToBinaryChange(ArcanistRepositoryAPI $api) {
 
     // Fill in the binary data from the working copy.
 
     $this->setOriginalFileData(
       $api->getOriginalFileData(
         $this->getOldPath()));
 
     $this->setCurrentFileData(
       $api->getCurrentFileData(
         $this->getCurrentPath()));
 
     $this->hunks = array();
     $this->setFileType(ArcanistDiffChangeType::FILE_BINARY);
     return $this;
   }
 
   protected function filterPath($path) {
     if ($path == '/dev/null') {
       return null;
     }
     return $path;
   }
 
   public function renderTextSummary() {
 
     $type = $this->getType();
     $file = $this->getFileType();
 
     $char = ArcanistDiffChangeType::getSummaryCharacterForChangeType($type);
     $attr = ArcanistDiffChangeType::getShortNameForFileType($file);
     if ($attr) {
       $attr = '('.$attr.')';
     }
 
     $summary = array();
     $summary[] = sprintf(
       '%s %5.5s %s',
       $char,
       $attr,
       $this->getCurrentPath());
     if (ArcanistDiffChangeType::isOldLocationChangeType($type)) {
       foreach ($this->getAwayPaths() as $path) {
         $summary[] = '             to: '.$path;
       }
     }
     if (ArcanistDiffChangeType::isNewLocationChangeType($type)) {
       $summary[] = '             from: '.$this->getOldPath();
     }
 
     return implode("\n", $summary);
   }
 
   public function getSymlinkTarget() {
     if ($this->getFileType() != ArcanistDiffChangeType::FILE_SYMLINK) {
       throw new Exception('Not a symlink!');
     }
     $hunks = $this->getHunks();
     $hunk = reset($hunks);
     $corpus = $hunk->getCorpus();
     $match = null;
     if (!preg_match('/^\+(?:link )?(.*)$/m', $corpus, $match)) {
       throw new Exception('Failed to extract link target!');
     }
     return trim($match[1]);
   }
 
   public function setNeedsSyntheticGitHunks($needs_synthetic_git_hunks) {
     $this->needsSyntheticGitHunks = $needs_synthetic_git_hunks;
     return $this;
   }
 
   public function getNeedsSyntheticGitHunks() {
     return $this->needsSyntheticGitHunks;
   }
 
 }
diff --git a/src/parser/diff/ArcanistDiffChangeType.php b/src/parser/diff/ArcanistDiffChangeType.php
index 60dd3fc4..2e513922 100644
--- a/src/parser/diff/ArcanistDiffChangeType.php
+++ b/src/parser/diff/ArcanistDiffChangeType.php
@@ -1,113 +1,112 @@
 <?php
 
 /**
  * Defines constants for file types and operations in changesets.
- *
- * @group diff
  */
 final class ArcanistDiffChangeType {
+
   const TYPE_ADD        = 1;
   const TYPE_CHANGE     = 2;
   const TYPE_DELETE     = 3;
   const TYPE_MOVE_AWAY  = 4;
   const TYPE_COPY_AWAY  = 5;
   const TYPE_MOVE_HERE  = 6;
   const TYPE_COPY_HERE  = 7;
   const TYPE_MULTICOPY  = 8;
   const TYPE_MESSAGE    = 9;
   const TYPE_CHILD      = 10;
 
   const FILE_TEXT       = 1;
   const FILE_IMAGE      = 2;
   const FILE_BINARY     = 3;
   const FILE_DIRECTORY  = 4;
   const FILE_SYMLINK    = 5;
   const FILE_DELETED    = 6;
   const FILE_NORMAL     = 7;
 
   public static function getSummaryCharacterForChangeType($type) {
     static $types = array(
       self::TYPE_ADD        => 'A',
       self::TYPE_CHANGE     => 'M',
       self::TYPE_DELETE     => 'D',
       self::TYPE_MOVE_AWAY  => 'V',
       self::TYPE_COPY_AWAY  => 'P',
       self::TYPE_MOVE_HERE  => 'V',
       self::TYPE_COPY_HERE  => 'P',
       self::TYPE_MULTICOPY  => 'P',
       self::TYPE_MESSAGE    => 'Q',
       self::TYPE_CHILD      => '@',
     );
     return idx($types, coalesce($type, '?'), '~');
   }
 
   public static function getShortNameForFileType($type) {
     static $names = array(
       self::FILE_TEXT       => null,
       self::FILE_DIRECTORY  => 'dir',
       self::FILE_IMAGE      => 'img',
       self::FILE_BINARY     => 'bin',
       self::FILE_SYMLINK    => 'sym',
     );
     return idx($names, coalesce($type, '?'), '???');
   }
 
   public static function isOldLocationChangeType($type) {
     static $types = array(
       ArcanistDiffChangeType::TYPE_MOVE_AWAY  => true,
       ArcanistDiffChangeType::TYPE_COPY_AWAY  => true,
       ArcanistDiffChangeType::TYPE_MULTICOPY  => true,
     );
     return isset($types[$type]);
   }
 
   public static function isNewLocationChangeType($type) {
     static $types = array(
       ArcanistDiffChangeType::TYPE_MOVE_HERE  => true,
       ArcanistDiffChangeType::TYPE_COPY_HERE  => true,
     );
     return isset($types[$type]);
   }
 
   public static function isDeleteChangeType($type) {
     static $types = array(
       ArcanistDiffChangeType::TYPE_DELETE     => true,
       ArcanistDiffChangeType::TYPE_MOVE_AWAY  => true,
       ArcanistDiffChangeType::TYPE_MULTICOPY  => true,
     );
     return isset($types[$type]);
   }
 
   public static function isCreateChangeType($type) {
     static $types = array(
       ArcanistDiffChangeType::TYPE_ADD        => true,
       ArcanistDiffChangeType::TYPE_COPY_HERE  => true,
       ArcanistDiffChangeType::TYPE_MOVE_HERE  => true,
     );
     return isset($types[$type]);
   }
 
   public static function isModifyChangeType($type) {
     static $types = array(
       ArcanistDiffChangeType::TYPE_CHANGE     => true,
     );
     return isset($types[$type]);
   }
 
   public static function getFullNameForChangeType($type) {
     static $types = array(
       self::TYPE_ADD        => 'Added',
       self::TYPE_CHANGE     => 'Modified',
       self::TYPE_DELETE     => 'Deleted',
       self::TYPE_MOVE_AWAY  => 'Moved Away',
       self::TYPE_COPY_AWAY  => 'Copied Away',
       self::TYPE_MOVE_HERE  => 'Moved Here',
       self::TYPE_COPY_HERE  => 'Copied Here',
       self::TYPE_MULTICOPY  => 'Deleted After Multiple Copy',
       self::TYPE_MESSAGE    => 'Commit Message',
       self::TYPE_CHILD      => 'Contents Modified',
     );
     return idx($types, coalesce($type, '?'), 'Unknown');
   }
 
 }
diff --git a/src/parser/diff/ArcanistDiffHunk.php b/src/parser/diff/ArcanistDiffHunk.php
index 78269f43..f47dd242 100644
--- a/src/parser/diff/ArcanistDiffHunk.php
+++ b/src/parser/diff/ArcanistDiffHunk.php
@@ -1,173 +1,171 @@
 <?php
 
 /**
  * Represents a contiguous set of added and removed lines in a diff.
- *
- * @group diff
  */
 final class ArcanistDiffHunk {
 
   protected $oldOffset;
   protected $oldLength;
   protected $newOffset;
   protected $newLength;
   protected $addLines;
   protected $delLines;
   protected $isMissingOldNewline = false;
   protected $isMissingNewNewline = false;
   protected $corpus;
 
   public function toDictionary() {
     return array(
       'oldOffset' => $this->oldOffset,
       'newOffset' => $this->newOffset,
       'oldLength' => $this->oldLength,
       'newLength' => $this->newLength,
       'addLines'  => $this->addLines,
       'delLines'  => $this->delLines,
       'isMissingOldNewline' => $this->isMissingOldNewline,
       'isMissingNewNewline' => $this->isMissingNewNewline,
       'corpus'    => (string)$this->corpus,
     );
   }
 
   public static function newFromDictionary(array $dict) {
     $obj = new ArcanistDiffHunk();
 
     $obj->oldOffset = $dict['oldOffset'];
     $obj->newOffset = $dict['newOffset'];
     $obj->oldLength = $dict['oldLength'];
     $obj->newLength = $dict['newLength'];
     $obj->addLines = $dict['addLines'];
     $obj->delLines = $dict['delLines'];
     $obj->isMissingOldNewline = $dict['isMissingOldNewline'];
     $obj->isMissingNewNewline = $dict['isMissingNewNewline'];
     $obj->corpus = $dict['corpus'];
 
     return $obj;
   }
 
   public function getChangedLines($type) {
     $old_map = array();
     $new_map = array();
     $cover_map = array();
 
     $oline = $this->getOldOffset();
     $nline = $this->getNewOffset();
     foreach (explode("\n", $this->getCorpus()) as $line) {
       $char = strlen($line) ? $line[0] : '~';
       switch ($char) {
         case '-':
           $old_map[$oline] = true;
           $cover_map[$oline] = true;
           ++$oline;
           break;
         case '+':
           $new_map[$nline] = true;
           if ($oline > 1) {
             $cover_map[$oline - 1] = true;
           }
           $cover_map[$oline] = true;
           ++$nline;
           break;
         default:
           ++$oline;
           ++$nline;
           break;
       }
     }
 
     switch ($type) {
       case 'new':
         return $new_map;
       case 'old':
         return $old_map;
       case 'cover':
         return $cover_map;
       default:
         throw new Exception("Unknown line change type '{$type}'.");
     }
   }
 
   public function setOldOffset($old_offset) {
     $this->oldOffset = $old_offset;
     return $this;
   }
 
   public function getOldOffset() {
     return $this->oldOffset;
   }
 
   public function setNewOffset($new_offset) {
     $this->newOffset = $new_offset;
     return $this;
   }
 
   public function getNewOffset() {
     return $this->newOffset;
   }
 
   public function setOldLength($old_length) {
     $this->oldLength = $old_length;
     return $this;
   }
 
   public function getOldLength() {
     return $this->oldLength;
   }
 
   public function setNewLength($new_length) {
     $this->newLength = $new_length;
     return $this;
   }
 
   public function getNewLength() {
     return $this->newLength;
   }
 
   public function setAddLines($add_lines) {
     $this->addLines = $add_lines;
     return $this;
   }
 
   public function getAddLines() {
     return $this->addLines;
   }
 
   public function setDelLines($del_lines) {
     $this->delLines = $del_lines;
     return $this;
   }
 
   public function getDelLines() {
     return $this->delLines;
   }
 
   public function setCorpus($corpus) {
     $this->corpus = $corpus;
     return $this;
   }
 
   public function getCorpus() {
     return $this->corpus;
   }
 
   public function setIsMissingOldNewline($missing) {
     $this->isMissingOldNewline = (bool)$missing;
     return $this;
   }
 
   public function getIsMissingOldNewline() {
     return $this->isMissingOldNewline;
   }
 
   public function setIsMissingNewNewline($missing) {
     $this->isMissingNewNewline = (bool)$missing;
     return $this;
   }
 
   public function getIsMissingNewNewline() {
     return $this->isMissingNewNewline;
   }
 
 }
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index d637fced..5f4d180b 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,1216 +1,1212 @@
 <?php
 
 /**
  * Interfaces with Git working copies.
- *
- * @group workingcopy
  */
 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;
 
   public static function newHookAPI($root) {
     return new ArcanistGitAPI($root);
   }
 
   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 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(
         "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 throuhgh 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 == ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
         $this->setBaseCommitExplanation(
           '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(
           "Unable to find any git commit named '{$symbolic_commit}' in ".
           "this repository.");
       }
 
       if ($this->symbolicHeadCommit === null) {
         $this->setBaseCommitExplanation(
           "it is the merge-base of the explicitly specified base commit ".
           "'{$symbolic_commit}' and HEAD.");
       } else {
         $this->setBaseCommitExplanation(
           "it is the merge-base of the explicitly specified base commit ".
           "'{$symbolic_commit}' and the explicitly specified head ".
           "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(
           'the repository has no commits.');
       } else {
         $this->setBaseCommitExplanation(
           '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(
           "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(
         "it is the merge-base of '{$default_relative}' and HEAD, as ".
         "specified in 'git.default-relative-commit' in '.arcconfig'. This ".
         "setting overrides other settings.");
     }
 
     if (!$default_relative) {
       list($err, $upstream) = $this->execManualLocal(
         "rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");
 
       if (!$err) {
         $default_relative = trim($upstream);
         $this->setBaseCommitExplanation(
           "it is the merge-base of '{$default_relative}' (the Git upstream ".
           "of the current branch) HEAD.");
       }
     }
 
     if (!$default_relative) {
       $default_relative = $this->readScratchFile('default-relative-commit');
       $default_relative = trim($default_relative);
       if ($default_relative) {
         $this->setBaseCommitExplanation(
           "it is the merge-base of '{$default_relative}' and HEAD, as ".
           "specified in '.git/arc/default-relative-commit'.");
       }
     }
 
     if (!$default_relative) {
 
       // TODO: Remove the history lesson soon.
 
       echo phutil_console_format(
         "<bg:green>** Select a Default Commit Range **</bg>\n\n");
       echo phutil_console_wrap(
         "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 'HEAD^' when you did not specify ".
         "a start revision, but this behavior does not make much sense in ".
         "most workflows outside of Facebook's historic git-svn workflow.\n\n".
         "arc no longer assumes 'HEAD^'. You must specify a relative commit ".
         "explicitly when you invoke a command (e.g., `arc diff HEAD^`, not ".
         "just `arc diff`) or select a default for this working copy.\n\n".
         "In most cases, the best default is 'origin/master'. You can also ".
         "select 'HEAD^' 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.)");
 
       $prompt = '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(
         "Relative commit '{$default_relative}' is not the name of a commit!");
     }
 
     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(
         "it is the merge-base of '{$default_relative}' and HEAD, as you ".
         "just specified.");
     }
 
     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;
   }
 
   final 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(
         "Unable to find any git commit named '{$symbolic_commit}' in ".
         "this repository.");
     }
 
     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',
     );
     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();
 
     $diff_revision = $base;
     if ($head) {
       $diff_revision .= '..'.$head;
     }
 
     list($stdout) = $this->execxLocal(
       "diff {$options} %s --",
       $diff_revision);
     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;
   }
 
   public function getBranchName() {
     // TODO: consider:
     //
     //    $ git rev-parse --abbrev-ref `git symbolic-ref HEAD`
     //
     // But that may fail if you're not on a branch.
     list($stdout) = $this->execxLocal('branch --no-color');
 
     // Assume that any branch beginning with '(' means 'no branch', or whatever
     // 'no branch' is in the current locale.
     $matches = null;
     if (preg_match('/^\* ([^\(].*)$/m', $stdout, $matches)) {
       return $matches[1];
     }
 
     return null;
   }
 
   public function getRemoteURI() {
     list($stdout) = $this->execxLocal('remote show -n origin');
 
     $matches = null;
     if (preg_match('/^\s*Fetch URL: (.*)$/m', $stdout, $matches)) {
       return trim($matches[1]);
     }
 
     return null;
   }
 
   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(
         'show -s --format=%C %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("Cannot find the {$vcs} equivalent "
-                                       ."of {$input}.");
+      throw new ArcanistUsageException(
+        "Cannot find the {$vcs} equivalent of {$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.
     );
 
     Futures($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->parseGitStatus($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->parseGitStatus($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;
   }
 
   public function getPreReceiveHookStatus($old_ref, $new_ref) {
     $options = $this->getDiffBaseOptions();
     list($stdout) = $this->execxLocal(
       "diff {$options} --raw %s %s --",
       $old_ref,
       $new_ref);
     return $this->parseGitStatus($stdout, $full = true);
   }
 
   private function parseGitStatus($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;
       $flag = $line[4];
       $file = $line[5];
       foreach ($flags as $key => $bits) {
         if ($flag == $key) {
           $mask |= $bits;
         }
       }
       if ($full) {
         $files[$file] = array(
           'mask' => $mask,
           'ref'  => rtrim($line[3], '.'),
         );
       } 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->parseGitStatus($stdout);
   }
 
   public function getBlame($path) {
     // TODO: 'git blame' supports --porcelain and we should probably use it.
     list($stdout) = $this->execxLocal(
       'blame --date=iso -w -M %s -- %s',
       $this->getBaseCommit(),
       $path);
 
     $blame = array();
     foreach (explode("\n", trim($stdout)) as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       // lines predating a git repo's history are blamed to the oldest revision,
       // with the commit hash prepended by a ^. we shouldn't count these lines
       // as blaming to the oldest diff's unfortunate author
       if ($line[0] == '^') {
         continue;
       }
 
       $matches = null;
       $ok = preg_match(
         '/^([0-9a-f]+)[^(]+?[(](.*?) +\d\d\d\d-\d\d-\d\d/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception("Bad blame? `{$line}'");
       }
       $revision = $matches[1];
       $author = $matches[2];
 
       $blame[] = array($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('Failed to parse git ls-tree output!');
       }
       $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() {
     list($branch_info) = $this->execxLocal(
       'branch --no-color');
     $lines = explode("\n", rtrim($branch_info));
 
     $result = array();
     foreach ($lines as $line) {
 
       if (preg_match('@^[* ]+\(no branch|detached from \w+/\w+\)@', $line)) {
         // This is indicating that the working copy is in a detached state;
         // just ignore it.
         continue;
       }
 
       list($current, $name) = preg_split('/\s+/', $line, 2);
       $result[] = array(
         'current' => !empty($current),
         'name'    => $name,
       );
     }
 
     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(
         '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('Merge failed!');
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return "You may now push this commit upstream, as appropriate (e.g. with ".
            "'git push', or 'git svn dcommit', or by printing and faxing it).";
   }
 
   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'] =
           "Commit message for '{$hash}' has explicit 'Differential Revision'.";
       }
 
       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'] =
         '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 '(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(
         "{$commit_hash} has already been reverted.");
     }
   }
 
   public function getBackoutMessage($commit_hash) {
     return 'This reverts commit '.$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(
               "it is the merge-base of '{$matches[1]}' and HEAD, as ".
               "specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             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;
           foreach ($commits as $commit) {
             list($branches) = $this->execxLocal(
               'branch --contains %s',
               $commit);
             $branches = array_filter(explode("\n", $branches));
             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) {
               foreach ($branches as $key => $branch) {
                 $branches[$key] = trim($branch, ' *');
               }
               $branches = implode(', ', $branches);
               $this->setBaseCommitExplanation(
                 "it is the first commit between '{$merge_base}' (the ".
                 "merge-base of '{$matches[1]}' and HEAD) which is also ".
                 "contained by another branch ({$branches}).");
               return $commit;
             }
           }
         } else {
           list($err) = $this->execManualLocal(
             'cat-file -t %s',
             $name);
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return $name;
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return self::GIT_MAGIC_ROOT_COMMIT;
           case 'amended':
             $text = $this->getCommitMessage('HEAD');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 "HEAD has been amended with 'Differential Revision:', ".
                 "as specified by '{$rule}' in your {$source} 'base' ".
                 "configuration.");
               return 'HEAD^';
             }
             break;
           case 'upstream':
             list($err, $upstream) = $this->execManualLocal(
               "rev-parse --abbrev-ref --symbolic-full-name '@{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(
                 "it is the merge-base of the upstream of the current branch ".
                 "and HEAD, and matched the rule '{$rule}' in your {$source} ".
                 "'base' configuration.");
               return $upstream_merge_base;
             }
             break;
           case 'this':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             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;
   }
 
 }
diff --git a/src/repository/api/ArcanistMercurialAPI.php b/src/repository/api/ArcanistMercurialAPI.php
index 6ba31870..27e579e8 100644
--- a/src/repository/api/ArcanistMercurialAPI.php
+++ b/src/repository/api/ArcanistMercurialAPI.php
@@ -1,1094 +1,1090 @@
 <?php
 
 /**
  * Interfaces with the Mercurial working copies.
- *
- * @group workingcopy
  */
 final class ArcanistMercurialAPI extends ArcanistRepositoryAPI {
 
   private $branch;
   private $localCommitInfo;
   private $rawDiffCache = array();
 
   private $supportsRebase;
   private $supportsPhases;
 
   protected function buildLocalFuture(array $argv) {
-
     // Mercurial has a "defaults" feature which basically breaks automation by
     // allowing the user to add random flags to any command. This feature is
     // "deprecated" and "a bad idea" that you should "forget ... existed"
     // according to project lead Matt Mackall:
     //
     //  http://markmail.org/message/hl3d6eprubmkkqh5
     //
     // There is an HGPLAIN environmental variable which enables "plain mode"
     // and hopefully disables this stuff.
 
     if (phutil_is_windows()) {
       $argv[0] = 'set HGPLAIN=1 & hg '.$argv[0];
     } else {
       $argv[0] = 'HGPLAIN=1 hg '.$argv[0];
     }
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   public function execPassthru($pattern /* , ... */) {
     $args = func_get_args();
     if (phutil_is_windows()) {
       $args[0] = 'hg '.$args[0];
     } else {
       $args[0] = 'HGPLAIN=1 hg '.$args[0];
     }
 
     return call_user_func_array('phutil_passthru', $args);
   }
 
   public function getSourceControlSystemName() {
     return 'hg';
   }
 
   public function getMetadataPath() {
     return $this->getPath('.hg');
   }
 
   public function getSourceControlBaseRevision() {
     return $this->getCanonicalRevisionName($this->getBaseCommit());
   }
 
   public function getCanonicalRevisionName($string) {
     $match = null;
     if ($this->isHgSubversionRepo() &&
         preg_match('/@([0-9]+)$/', $string, $match)) {
       $string = hgsprintf('svnrev(%s)', $match[1]);
     }
 
     list($stdout) = $this->execxLocal(
       'log -l 1 --template %s -r %s --',
       '{node}',
       $string);
     return $stdout;
   }
 
   public function getHashFromFromSVNRevisionNumber($revision_id) {
     $matches = array();
     $string = hgsprintf('svnrev(%s)', $revision_id);
     list($stdout) = $this->execxLocal(
       'log -l 1 --template %s -r %s --',
       '{node}',
        $string);
     if (!$stdout) {
-      throw new ArcanistUsageException("Cannot find the HG equivalent "
-                                       ."of {$revision_id} given.");
+      throw new ArcanistUsageException(
+        "Cannot find the HG equivalent of {$revision_id} given.");
     }
     return $stdout;
   }
 
 
   public function getSVNRevisionNumberFromHash($hash) {
     $matches = array();
     list($stdout) = $this->execxLocal(
       'log -r %s --template {svnrev}', $hash);
     if (!$stdout) {
-      throw new ArcanistUsageException("Cannot find the SVN equivalent "
-                                       ."of {$hash} given.");
+      throw new ArcanistUsageException(
+        "Cannot find the SVN equivalent of {$hash} given.");
     }
     return $stdout;
   }
 
   public function getSourceControlPath() {
     return '/';
   }
 
   public function getBranchName() {
     if (!$this->branch) {
       list($stdout) = $this->execxLocal('branch');
       $this->branch = trim($stdout);
     }
     return $this->branch;
   }
 
   public function didReloadCommitRange() {
     $this->localCommitInfo = null;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     if ($symbolic_commit !== null) {
       try {
         $commit = $this->getCanonicalRevisionName(
           hgsprintf('ancestor(%s,.)', $symbolic_commit));
       } catch (Exception $ex) {
         // Try it as a revset instead of a commit id
         try {
           $commit = $this->getCanonicalRevisionName(
             hgsprintf('ancestor(%R,.)', $symbolic_commit));
         } catch (Exception $ex) {
           throw new ArcanistUsageException(
-          "Commit '{$symbolic_commit}' is not a valid Mercurial commit ".
-          "identifier.");
+            "Commit '{$symbolic_commit}' is not a valid Mercurial commit ".
+            "identifier.");
         }
       }
 
-      $this->setBaseCommitExplanation('it is the greatest common ancestor of '.
-        'the working directory and the commit you specified explicitly.');
+      $this->setBaseCommitExplanation(
+        'it is the greatest common ancestor of the working directory '.
+        'and the commit you specified explicitly.');
       return $commit;
     }
 
     if ($this->getBaseCommitArgumentRules() ||
         $this->getConfigurationManager()->getConfigFromAnySource('base')) {
       $base = $this->resolveBaseCommit();
       if (!$base) {
         throw new ArcanistUsageException(
           "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;
     }
 
     // Mercurial 2.1 and up have phases which indicate if something is
     // published or not. To find which revs are outgoing, it's much
     // faster to check the phase instead of actually checking the server.
     if ($this->supportsPhases()) {
       list($err, $stdout) = $this->execManualLocal(
         'log --branch %s -r %s --style default',
         $this->getBranchName(),
         'draft()');
     } else {
       list($err, $stdout) = $this->execManualLocal(
         'outgoing --branch %s --style default',
-      $this->getBranchName());
+        $this->getBranchName());
     }
 
     if (!$err) {
       $logs = ArcanistMercurialParser::parseMercurialLog($stdout);
     } else {
       // Mercurial (in some versions?) raises an error when there's nothing
       // outgoing.
       $logs = array();
     }
 
     if (!$logs) {
       $this->setBaseCommitExplanation(
         'you have no outgoing commits, so arc assumes you intend to submit '.
         'uncommitted changes in the working copy.');
       return $this->getWorkingCopyRevision();
     }
 
     $outgoing_revs = ipull($logs, 'rev');
 
     // This is essentially an implementation of a theoretical `hg merge-base`
     // command.
     $against = $this->getWorkingCopyRevision();
     while (true) {
       // NOTE: The "^" and "~" syntaxes were only added in hg 1.9, which is
       // new as of July 2011, so do this in a compatible way. Also, "hg log"
       // and "hg outgoing" don't necessarily show parents (even if given an
       // explicit template consisting of just the parents token) so we need
       // to separately execute "hg parents".
 
       list($stdout) = $this->execxLocal(
         'parents --style default --rev %s',
         $against);
       $parents_logs = ArcanistMercurialParser::parseMercurialLog($stdout);
 
       list($p1, $p2) = array_merge($parents_logs, array(null, null));
 
       if ($p1 && !in_array($p1['rev'], $outgoing_revs)) {
         $against = $p1['rev'];
         break;
       } else if ($p2 && !in_array($p2['rev'], $outgoing_revs)) {
         $against = $p2['rev'];
         break;
       } else if ($p1) {
         $against = $p1['rev'];
       } else {
         // This is the case where you have a new repository and the entire
         // thing is outgoing; Mercurial literally accepts "--rev null" as
         // meaning "diff against the empty state".
         $against = 'null';
         break;
       }
     }
 
     if ($against == 'null') {
       $this->setBaseCommitExplanation(
         'this is a new repository (all changes are outgoing).');
     } else {
       $this->setBaseCommitExplanation(
         'it is the first commit reachable from the working copy state '.
         'which is not outgoing.');
     }
 
     return $against;
   }
 
   public function getLocalCommitInformation() {
     if ($this->localCommitInfo === null) {
       $base_commit = $this->getBaseCommit();
       list($info) = $this->execxLocal(
         'log --template %s --rev %s --branch %s --',
         "{node}\1{rev}\1{author}\1".
           "{date|rfc822date}\1{branch}\1{tag}\1{parents}\1{desc}\2",
         hgsprintf('(%s::. - %s)', $base_commit, $base_commit),
         $this->getBranchName());
       $logs = array_filter(explode("\2", $info));
 
       $last_node = null;
 
       $futures = array();
 
       $commits = array();
       foreach ($logs as $log) {
         list($node, $rev, $full_author, $date, $branch, $tag,
           $parents, $desc) = explode("\1", $log, 9);
 
         list ($author, $author_email) = $this->parseFullAuthor($full_author);
 
         // NOTE: If a commit has only one parent, {parents} returns empty.
         // If it has two parents, {parents} returns revs and short hashes, not
         // full hashes. Try to avoid making calls to "hg parents" because it's
         // relatively expensive.
         $commit_parents = null;
         if (!$parents) {
           if ($last_node) {
             $commit_parents = array($last_node);
           }
         }
 
         if (!$commit_parents) {
           // We didn't get a cheap hit on previous commit, so do the full-cost
           // "hg parents" call. We can run these in parallel, at least.
           $futures[$node] = $this->execFutureLocal(
             'parents --template %s --rev %s',
             '{node}\n',
             $node);
         }
 
         $commits[$node] = array(
           'author'  => $author,
           'time'    => strtotime($date),
           'branch'  => $branch,
           'tag'     => $tag,
           'commit'  => $node,
           'rev'     => $node, // TODO: Remove eventually.
           'local'   => $rev,
           'parents' => $commit_parents,
           'summary' => head(explode("\n", $desc)),
           'message' => $desc,
           'authorEmail' => $author_email,
         );
 
         $last_node = $node;
       }
 
       foreach (Futures($futures)->limit(4) as $node => $future) {
         list($parents) = $future->resolvex();
         $parents = array_filter(explode("\n", $parents));
         $commits[$node]['parents'] = $parents;
       }
 
       // Put commits in newest-first order, to be consistent with Git and the
       // expected order of "hg log" and "git log" under normal circumstances.
       // The order of ancestors() is oldest-first.
       $commits = array_reverse($commits);
 
       $this->localCommitInfo = $commits;
     }
 
     return $this->localCommitInfo;
   }
 
   public function getAllFiles() {
     // TODO: Handle paths with newlines.
     $future = $this->buildLocalFuture(array('manifest'));
     return new LinesOfALargeExecFuture($future);
   }
 
   public function getChangedFiles($since_commit) {
     list($stdout) = $this->execxLocal(
       'status --rev %s',
       $since_commit);
     return ArcanistMercurialParser::parseMercurialStatus($stdout);
   }
 
   public function getBlame($path) {
     list($stdout) = $this->execxLocal(
       'annotate -u -v -c --rev %s -- %s',
       $this->getBaseCommit(),
       $path);
 
     $lines = phutil_split_lines($stdout, $retain_line_endings = true);
 
     $blame = array();
     foreach ($lines as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       $matches = null;
       $ok = preg_match('/^\s*([^:]+?) ([a-f0-9]{12}):/', $line, $matches);
 
       if (!$ok) {
         throw new Exception("Unable to parse Mercurial blame line: {$line}");
       }
 
       $revision = $matches[2];
       $author = trim($matches[1]);
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   protected function buildUncommittedStatus() {
     list($stdout) = $this->execxLocal('status');
 
     $results = new PhutilArrayWithDefaultValue();
 
     $working_status = ArcanistMercurialParser::parseMercurialStatus($stdout);
     foreach ($working_status as $path => $mask) {
       if (!($mask & ArcanistRepositoryAPI::FLAG_UNTRACKED)) {
         // Mark tracked files as uncommitted.
         $mask |= self::FLAG_UNCOMMITTED;
       }
 
       $results[$path] |= $mask;
     }
 
     return $results->toArray();
   }
 
   protected function buildCommitRangeStatus() {
     // TODO: Possibly we should use "hg status --rev X --rev ." for this
     // instead, but we must run "hg diff" later anyway in most cases, so
     // building and caching it shouldn't hurt us.
 
     $diff = $this->getFullMercurialDiff();
     if (!$diff) {
       return array();
     }
 
     $parser = new ArcanistDiffParser();
     $changes = $parser->parseDiff($diff);
 
     $status_map = array();
     foreach ($changes as $change) {
       $flags = 0;
       switch ($change->getType()) {
         case ArcanistDiffChangeType::TYPE_ADD:
         case ArcanistDiffChangeType::TYPE_MOVE_HERE:
         case ArcanistDiffChangeType::TYPE_COPY_HERE:
           $flags |= self::FLAG_ADDED;
           break;
         case ArcanistDiffChangeType::TYPE_CHANGE:
         case ArcanistDiffChangeType::TYPE_COPY_AWAY: // Check for changes?
           $flags |= self::FLAG_MODIFIED;
           break;
         case ArcanistDiffChangeType::TYPE_DELETE:
         case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
         case ArcanistDiffChangeType::TYPE_MULTICOPY:
           $flags |= self::FLAG_DELETED;
           break;
       }
       $status_map[$change->getCurrentPath()] = $flags;
     }
 
     return $status_map;
   }
 
   protected function didReloadWorkingCopy() {
     // Diffs are against ".", so we need to drop the cache if we change the
     // working copy.
     $this->rawDiffCache = array();
     $this->branch = null;
   }
 
   private function getDiffOptions() {
     $options = array(
       '--git',
       '-U'.$this->getDiffLinesOfContext(),
     );
     return implode(' ', $options);
   }
 
   public function getRawDiffText($path) {
     $options = $this->getDiffOptions();
 
     $range = $this->getBaseCommit();
 
     $raw_diff_cache_key = $options.' '.$range.' '.$path;
     if (idx($this->rawDiffCache, $raw_diff_cache_key)) {
       return idx($this->rawDiffCache, $raw_diff_cache_key);
     }
 
     list($stdout) = $this->execxLocal(
       'diff %C --rev %s -- %s',
       $options,
       $range,
       $path);
 
     $this->rawDiffCache[$raw_diff_cache_key] = $stdout;
 
     return $stdout;
   }
 
   public function getFullMercurialDiff() {
     return $this->getRawDiffText('');
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getBaseCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision(
       $path,
       $this->getWorkingCopyRevision());
   }
 
   public function getBulkOriginalFileData($paths) {
     return $this->getBulkFileDataAtRevision($paths, $this->getBaseCommit());
   }
 
   public function getBulkCurrentFileData($paths) {
     return $this->getBulkFileDataAtRevision(
       $paths,
       $this->getWorkingCopyRevision());
   }
 
   private function getBulkFileDataAtRevision($paths, $revision) {
     // Calling 'hg cat' on each file individually is slow (1 second per file
     // on a large repo) because mercurial has to decompress and parse the
-    // entire manifest every time.  Do it in one large batch instead.
+    // entire manifest every time. Do it in one large batch instead.
 
     // hg cat will write the file data to files in a temp directory
     $tmpdir = Filesystem::createTemporaryDirectory();
 
     // Mercurial doesn't create the directories for us :(
     foreach ($paths as $path) {
       $tmppath = $tmpdir.'/'.$path;
       Filesystem::createDirectory(dirname($tmppath), 0755, true);
     }
 
     list($err, $stdout) = $this->execManualLocal(
       'cat --rev %s --output %s -- %C',
       $revision,
       // %p is the formatter for the repo-relative filepath
       $tmpdir.'/%p',
       implode(' ', $paths));
 
     $filedata = array();
     foreach ($paths as $path) {
       $tmppath = $tmpdir.'/'.$path;
       if (Filesystem::pathExists($tmppath)) {
         $filedata[$path] = Filesystem::readFile($tmppath);
       }
     }
 
     Filesystem::remove($tmpdir);
 
     return $filedata;
   }
 
   private function getFileDataAtRevision($path, $revision) {
     list($err, $stdout) = $this->execManualLocal(
       'cat --rev %s -- %s',
       $revision,
       $path);
     if ($err) {
       // Assume this is "no file at revision", i.e. a deleted or added file.
       return null;
     } else {
       return $stdout;
     }
   }
 
   public function getWorkingCopyRevision() {
     return '.';
   }
 
   public function isHistoryDefaultImmutable() {
     return true;
   }
 
   public function supportsAmend() {
     list($err, $stdout) = $this->execManualLocal('help commit');
     if ($err) {
       return false;
     } else {
       return (strpos($stdout, 'amend') !== false);
     }
   }
 
   public function supportsRebase() {
     if ($this->supportsRebase === null) {
       list ($err) = $this->execManualLocal('help rebase');
       $this->supportsRebase = $err === 0;
     }
 
     return $this->supportsRebase;
   }
 
   public function supportsPhases() {
     if ($this->supportsPhases === null) {
       list ($err) = $this->execManualLocal('help phase');
       $this->supportsPhases = $err === 0;
     }
 
     return $this->supportsPhases;
   }
 
   public function supportsCommitRanges() {
     return true;
   }
 
   public function supportsLocalCommits() {
     return true;
   }
 
   public function getAllBranches() {
     list($branch_info) = $this->execxLocal('bookmarks');
     if (trim($branch_info) == 'no bookmarks set') {
       return array();
     }
 
     $matches = null;
     preg_match_all(
       '/^\s*(\*?)\s*(.+)\s(\S+)$/m',
       $branch_info,
       $matches,
       PREG_SET_ORDER);
 
     $return = array();
     foreach ($matches as $match) {
       list(, $current, $name) = $match;
       $return[] = array(
         'current' => (bool)$current,
         'name'    => rtrim($name),
       );
     }
     return $return;
   }
 
   public function hasLocalCommit($commit) {
     try {
       $this->getCanonicalRevisionName($commit);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   public function getCommitMessage($commit) {
     list($message) = $this->execxLocal(
       'log --template={desc} --rev %s',
       $commit);
     return $message;
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullMercurialDiff();
     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) {
       $err = phutil_passthru(
         '(cd %s && HGPLAIN=1 hg merge --rev %s && hg commit -m %s)',
         $this->getPath(),
         $branch,
         $message);
     } else {
       $err = phutil_passthru(
         '(cd %s && HGPLAIN=1 hg merge && hg commit -m %s)',
         $this->getPath(),
         $message);
     }
 
     if ($err) {
       throw new ArcanistUsageException('Merge failed!');
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return "You may now push this commit upstream, as appropriate (e.g. with ".
            "'hg push' or by printing and faxing it).";
   }
 
   public function getCommitMessageLog() {
     $base_commit = $this->getBaseCommit();
     list($stdout) = $this->execxLocal(
       'log --template %s --rev %s --branch %s --',
       "{node}\1{desc}\2",
       hgsprintf('(%s::. - %s)', $base_commit, $base_commit),
       $this->getBranchName());
 
     $map = array();
 
     $logs = explode("\2", trim($stdout));
     foreach (array_filter($logs) as $log) {
       list($node, $desc) = explode("\1", $log);
       $map[$node] = $desc;
     }
 
     return array_reverse($map);
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getCommitMessageLog();
     $parser = new ArcanistDiffParser();
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $node_id => $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
 
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $node_id;
       }
     }
 
     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'] =
           "Commit message for '{$hash}' has explicit 'Differential Revision'.";
       }
 
       return $results;
     }
 
     // Try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('hgcm', $commit['commit']);
     }
 
     if ($hashes) {
 
       // NOTE: In the case of "arc diff . --uncommitted" in a Mercurial working
       // copy with dirty changes, there may be no local commits.
 
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'commitHashes' => $hashes,
         ));
 
       foreach ($results as $key => $hash) {
         $results[$key]['why'] =
           'A mercurial commit hash in the commit range is already attached '.
           'to the Differential revision.';
       }
 
       return $results;
     }
 
     return array();
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('up');
     $this->reloadWorkingCopy();
   }
 
   private function getMercurialConfig($key, $default = null) {
     list($stdout) = $this->execxLocal('showconfig %s', $key);
     if ($stdout == '') {
       return $default;
     }
     return rtrim($stdout);
   }
 
   public function getAuthor() {
     $full_author = $this->getMercurialConfig('ui.username');
     list($author, $author_email) = $this->parseFullAuthor($full_author);
     return $author;
   }
 
   /**
-   * Parse the Mercurial author field
+   * Parse the Mercurial author field.
    *
    * Not everyone enters their email address as a part of the username
-   * field. Try to make it work when it's obvious
+   * field. Try to make it work when it's obvious.
    *
    * @param string $full_author
    * @return array
    */
   protected function parseFullAuthor($full_author) {
     if (strpos($full_author, '@') === false) {
       $author = $full_author;
       $author_email = null;
     } else {
       $email = new PhutilEmailAddress($full_author);
       $author = $email->getDisplayName();
       $author_email = $email->getAddress();
     }
 
     return array($author, $author_email);
   }
 
   public function addToCommit(array $paths) {
     $this->execxLocal(
       'addremove -- %Ls',
       $paths);
     $this->reloadWorkingCopy();
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
-    $this->execxLocal(
-      'commit -l %s',
-      $tmp_file);
+    $this->execxLocal('commit -l %s', $tmp_file);
     $this->reloadWorkingCopy();
   }
 
   public function amendCommit($message = null) {
     if ($message === null) {
       $message = $this->getCommitMessage('.');
     }
 
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
 
     try {
       $this->execxLocal(
         'commit --amend -l %s',
         $tmp_file);
     } catch (CommandException $ex) {
       if (preg_match('/nothing changed/', $ex->getStdOut())) {
         // NOTE: Mercurial considers it an error to make a no-op amend. Although
         // we generally defer to the underlying VCS to dictate behavior, this
         // one seems a little goofy, and we use amend as part of various
         // workflows under the assumption that no-op amends are fine. If this
         // amend failed because it's a no-op, just continue.
       } else {
         throw $ex;
       }
     }
 
     $this->reloadWorkingCopy();
   }
 
   public function getCommitSummary($commit) {
     if ($commit == 'null') {
       return '(The Empty Void)';
     }
 
     list($summary) = $this->execxLocal(
       'log --template {desc} --limit 1 --rev %s',
       $commit);
 
     $summary = head(explode("\n", $summary));
 
     return trim($summary);
   }
 
   public function backoutCommit($commit_hash) {
     $this->execxLocal(
       'backout -r %s', $commit_hash);
     $this->reloadWorkingCopy();
     if (!$this->getUncommittedStatus()) {
       throw new ArcanistUsageException(
         "{$commit_hash} has already been reverted.");
     }
   }
 
   public function getBackoutMessage($commit_hash) {
     return 'Backed out changeset '.$commit_hash.'.';
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     list($type, $name) = explode(':', $rule, 2);
 
     // NOTE: This function MUST return node hashes or symbolic commits (like
     // branch names or the word "tip"), not revsets. This includes ".^" and
     // similar, which a revset, not a symbolic commit identifier. If you return
     // a revset it will be escaped later and looked up literally.
 
     switch ($type) {
       case 'hg':
         $matches = null;
         if (preg_match('/^gca\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'log --template={node} --rev %s',
             sprintf('ancestor(., %s)', $matches[1]));
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is the greatest common ancestor of '{$matches[1]}' and ., as".
               " specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return trim($merge_base);
           }
         } else {
           list($err, $commit) = $this->execManualLocal(
             'log --template {node} --rev %s',
             hgsprintf('%s', $name));
 
           if ($err) {
             list($err, $commit) = $this->execManualLocal(
               'log --template {node} --rev %s',
               $name);
           }
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return trim($commit);
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return 'null';
           case 'outgoing':
             list($err, $outgoing_base) = $this->execManualLocal(
               'log --template={node} --rev %s',
               'limit(reverse(ancestors(.) - outgoing()), 1)');
             if (!$err) {
               $this->setBaseCommitExplanation(
                 "it is the first ancestor of the working copy that is not ".
                 "outgoing, and it matched the rule {$rule} in your {$source} ".
                 "'base' configuration.");
               return trim($outgoing_base);
             }
           case 'amended':
             $text = $this->getCommitMessage('.');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 "'.' has been amended with 'Differential Revision:', ".
                 "as specified by '{$rule}' in your {$source} 'base' ".
                 "configuration.");
               // NOTE: This should be safe because Mercurial doesn't support
               // amend until 2.2.
               return $this->getCanonicalRevisionName('.^');
             }
             break;
           case 'bookmark':
             $revset =
               'limit('.
               '  sort('.
               '    (ancestors(.) and bookmark() - .) or'.
               '    (ancestors(.) - outgoing()), '.
               '  -rev),'.
               '1)';
             list($err, $bookmark_base) = $this->execManualLocal(
               'log --template={node} --rev %s',
               $revset);
             if (!$err) {
               $this->setBaseCommitExplanation(
                 "it is the first ancestor of . that either has a bookmark, or ".
                 "is already in the remote and it matched the rule {$rule} in ".
                 "your {$source} 'base' configuration");
               return trim($bookmark_base);
             }
             break;
           case 'this':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return $this->getCanonicalRevisionName('.^');
           default:
             if (preg_match('/^nodiff\((.+)\)$/', $name, $matches)) {
               list($results) = $this->execxLocal(
                 'log --template %s --rev %s',
                 "{node}\1{desc}\2",
                 sprintf('ancestor(.,%s)::.^', $matches[1]));
               $results = array_reverse(explode("\2", trim($results)));
 
               foreach ($results as $result) {
                 if (empty($result)) {
                   continue;
                 }
 
                 list($node, $desc) = explode("\1", $result, 2);
 
                 $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
                   $desc);
                 if ($message->getRevisionID()) {
                   $this->setBaseCommitExplanation(
                     "it is the first ancestor of . that has a diff ".
                     "and is the gca or a descendant of the gca with ".
                     "'{$matches[1]}', specified by '{$rule}' in your ".
                     "{$source} 'base' configuration.");
                   return $node;
                 }
               }
             }
             break;
           }
         break;
       default:
         return null;
     }
 
     return null;
 
   }
 
   public function isHgSubversionRepo() {
     return file_exists($this->getPath('.hg/svn/rev_map'));
   }
 
   public function getSubversionInfo() {
     $info = array();
     $base_path = null;
     $revision = null;
     list($err, $raw_info) = $this->execManualLocal('svn info');
     if (!$err) {
       foreach (explode("\n", trim($raw_info)) as $line) {
         list($key, $value) = explode(': ', $line, 2);
         switch ($key) {
           case 'URL':
             $info['base_path'] = $value;
             $base_path = $value;
             break;
           case 'Repository UUID':
             $info['uuid'] = $value;
             break;
           case 'Revision':
             $revision = $value;
             break;
           default:
             break;
         }
       }
       if ($base_path && $revision) {
         $info['base_revision'] = $base_path.'@'.$revision;
       }
     }
     return $info;
   }
 
   public function getActiveBookmark() {
     $bookmarks = $this->getBookmarks();
     foreach ($bookmarks as $bookmark) {
       if ($bookmark['is_active']) {
         return $bookmark['name'];
       }
     }
 
     return null;
   }
 
   public function isBookmark($name) {
     $bookmarks = $this->getBookmarks();
     foreach ($bookmarks as $bookmark) {
       if ($bookmark['name'] === $name) {
         return true;
       }
     }
 
     return false;
   }
 
   public function isBranch($name) {
     $branches = $this->getBranches();
     foreach ($branches as $branch) {
       if ($branch['name'] === $name) {
         return true;
       }
     }
 
     return false;
   }
 
   public function getBranches() {
     list($stdout) = $this->execxLocal('--debug branches');
     $lines = ArcanistMercurialParser::parseMercurialBranches($stdout);
 
     $branches = array();
     foreach ($lines as $name => $spec) {
       $branches[] = array(
         'name' => $name,
         'revision' => $spec['rev'],
       );
     }
 
     return $branches;
   }
 
   public function getBookmarks() {
     $bookmarks = array();
 
     list($raw_output) = $this->execxLocal('bookmarks');
     $raw_output = trim($raw_output);
     if ($raw_output !== 'no bookmarks set') {
       foreach (explode("\n", $raw_output) as $line) {
         // example line:  * mybook               2:6b274d49be97
         list($name, $revision) = $this->splitBranchOrBookmarkLine($line);
 
         $is_active = false;
         if ('*' === $name[0]) {
           $is_active = true;
           $name = substr($name, 2);
         }
 
         $bookmarks[] = array(
           'is_active' => $is_active,
           'name' => $name,
           'revision' => $revision);
       }
     }
 
     return $bookmarks;
   }
 
   private function splitBranchOrBookmarkLine($line) {
     // branches and bookmarks are printed in the format:
     // default                 0:a5ead76cdf85 (inactive)
     // * mybook               2:6b274d49be97
     // this code divides the name half from the revision half
     // it does not parse the * and (inactive) bits
     $colon_index = strrpos($line, ':');
     $before_colon = substr($line, 0, $colon_index);
     $start_rev_index = strrpos($before_colon, ' ');
     $name = substr($line, 0, $start_rev_index);
     $rev = substr($line, $start_rev_index);
 
     return array(trim($name), trim($rev));
   }
 
   public function getRemoteURI() {
     list($stdout) = $this->execxLocal('paths default');
 
     $stdout = trim($stdout);
     if (strlen($stdout)) {
       return $stdout;
     }
 
     return null;
   }
 
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index 10da4697..2c1956f4 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,660 +1,659 @@
 <?php
 
 /**
  * Interfaces with the VCS in the working copy.
  *
  * @task  status      Path Status
- * @group workingcopy
  */
 abstract class ArcanistRepositoryAPI {
 
   const FLAG_MODIFIED     = 1;
   const FLAG_ADDED        = 2;
   const FLAG_DELETED      = 4;
   const FLAG_UNTRACKED    = 8;
   const FLAG_CONFLICT     = 16;
   const FLAG_MISSING      = 32;
   const FLAG_UNSTAGED     = 64;
   const FLAG_UNCOMMITTED  = 128;
   const FLAG_EXTERNALS    = 256;
 
   // Occurs in SVN when you replace a file with a directory without telling
   // SVN about it.
   const FLAG_OBSTRUCTED   = 512;
 
   // Occurs in SVN when an update was interrupted or failed, e.g. you ^C'd it.
   const FLAG_INCOMPLETE   = 1024;
 
   protected $path;
   protected $diffLinesOfContext = 0x7FFF;
   private $baseCommitExplanation = '???';
   private $configurationManager;
   private $baseCommitArgumentRules;
 
   private $uncommittedStatusCache;
   private $commitRangeStatusCache;
 
   private $symbolicBaseCommit;
   private $resolvedBaseCommit;
 
   abstract public function getSourceControlSystemName();
 
   public function getDiffLinesOfContext() {
     return $this->diffLinesOfContext;
   }
 
   public function setDiffLinesOfContext($lines) {
     $this->diffLinesOfContext = $lines;
     return $this;
   }
 
   public function getWorkingCopyIdentity() {
     return $this->configurationManager->getWorkingCopyIdentity();
   }
 
   public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public static function newAPIFromConfigurationManager(
     ArcanistConfigurationManager $configuration_manager) {
 
     $working_copy = $configuration_manager->getWorkingCopyIdentity();
 
     if (!$working_copy) {
       throw new Exception(
         pht(
           'Trying to create a RepositoryAPI without a working copy!'));
     }
 
     $root = $working_copy->getProjectRoot();
     switch ($working_copy->getVCSType()) {
       case 'svn':
         $api = new ArcanistSubversionAPI($root);
         break;
       case 'hg':
         $api = new ArcanistMercurialAPI($root);
         break;
       case 'git':
         $api = new ArcanistGitAPI($root);
         break;
       default:
         throw new Exception(
           pht(
             'The current working directory is not part of a working copy for '.
             'a supported version control system (Git, Subversion or '.
             'Mercurial).'));
     }
 
     $api->configurationManager = $configuration_manager;
     return $api;
   }
 
   public function __construct($path) {
     $this->path = $path;
   }
 
   public function getPath($to_file = null) {
     if ($to_file !== null) {
       return $this->path.DIRECTORY_SEPARATOR.
              ltrim($to_file, DIRECTORY_SEPARATOR);
     } else {
       return $this->path.DIRECTORY_SEPARATOR;
     }
   }
 
 
 /* -(  Path Status  )-------------------------------------------------------- */
 
 
   abstract protected function buildUncommittedStatus();
   abstract protected function buildCommitRangeStatus();
 
 
   /**
    * Get a list of uncommitted paths in the working copy that have been changed
    * or are affected by other status effects, like conflicts or untracked
    * files.
    *
    * Convenience methods @{method:getUntrackedChanges},
    * @{method:getUnstagedChanges}, @{method:getUncommittedChanges},
    * @{method:getMergeConflicts}, and @{method:getIncompleteChanges} allow
    * simpler selection of paths in a specific state.
    *
    * This method returns a map of paths to bitmasks with status, using
    * `FLAG_` constants. For example:
    *
    *   array(
    *     'some/uncommitted/file.txt' => ArcanistRepositoryAPI::FLAG_UNSTAGED,
    *   );
    *
    * A file may be in several states. Not all states are possible with all
    * version control systems.
    *
    * @return map<string, bitmask> Map of paths, see above.
    * @task status
    */
   final public function getUncommittedStatus() {
     if ($this->uncommittedStatusCache === null) {
       $status = $this->buildUncommittedStatus();
       ksort($status);
       $this->uncommittedStatusCache = $status;
     }
     return $this->uncommittedStatusCache;
   }
 
 
   /**
    * @task status
    */
   final public function getUntrackedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNTRACKED);
   }
 
 
   /**
    * @task status
    */
   final public function getUnstagedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNSTAGED);
   }
 
 
   /**
    * @task status
    */
   final public function getUncommittedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNCOMMITTED);
   }
 
 
   /**
    * @task status
    */
   final public function getMergeConflicts() {
     return $this->getUncommittedPathsWithMask(self::FLAG_CONFLICT);
   }
 
 
   /**
    * @task status
    */
   final public function getIncompleteChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_INCOMPLETE);
   }
 
 
   /**
    * @task status
    */
   final public function getMissingChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_MISSING);
   }
 
 
   /**
    * @task status
    */
   private function getUncommittedPathsWithMask($mask) {
     $match = array();
     foreach ($this->getUncommittedStatus() as $path => $flags) {
       if ($flags & $mask) {
         $match[] = $path;
       }
     }
     return $match;
   }
 
 
   /**
    * Get a list of paths affected by the commits in the current commit range.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getCommitRangeStatus() {
     if ($this->commitRangeStatusCache === null) {
       $status = $this->buildCommitRangeStatus();
       ksort($status);
       $this->commitRangeStatusCache = $status;
     }
     return $this->commitRangeStatusCache;
   }
 
 
   /**
    * Get a list of paths affected by commits in the current commit range, or
    * uncommitted changes in the working copy. See @{method:getUncommittedStatus}
    * or @{method:getCommitRangeStatus} to retreive smaller parts of the status.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getWorkingCopyStatus() {
     $range_status = $this->getCommitRangeStatus();
     $uncommitted_status = $this->getUncommittedStatus();
 
     $result = new PhutilArrayWithDefaultValue($range_status);
     foreach ($uncommitted_status as $path => $mask) {
       $result[$path] |= $mask;
     }
 
     $result = $result->toArray();
     ksort($result);
     return $result;
   }
 
 
   /**
    * Drops caches after changes to the working copy. By default, some queries
    * against the working copy are cached. They
    *
    * @return this
    * @task status
    */
   final public function reloadWorkingCopy() {
     $this->uncommittedStatusCache = null;
     $this->commitRangeStatusCache = null;
 
     $this->didReloadWorkingCopy();
     $this->reloadCommitRange();
 
     return $this;
   }
 
 
   /**
    * Hook for implementations to dirty working copy caches after the working
    * copy has been updated.
    *
    * @return this
    * @task status
    */
   protected function didReloadWorkingCopy() {
     return;
   }
 
 
   /**
    * Fetches the original file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkOriginalFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getOriginalFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * Fetches the current file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkCurrentFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getCurrentFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * @return Traversable
    */
   abstract public function getAllFiles();
 
   abstract public function getBlame($path);
 
   abstract public function getRawDiffText($path);
   abstract public function getOriginalFileData($path);
   abstract public function getCurrentFileData($path);
   abstract public function getLocalCommitInformation();
   abstract public function getSourceControlBaseRevision();
   abstract public function getCanonicalRevisionName($string);
   abstract public function getBranchName();
   abstract public function getSourceControlPath();
   abstract public function isHistoryDefaultImmutable();
   abstract public function supportsAmend();
   abstract public function getWorkingCopyRevision();
   abstract public function updateWorkingCopy();
   abstract public function getMetadataPath();
   abstract public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query);
   abstract public function getRemoteURI();
 
 
   public function getUnderlyingWorkingCopyRevision() {
     return $this->getWorkingCopyRevision();
   }
 
   public function getChangedFiles($since_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAuthor() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function addToCommit(array $paths) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalCommits();
 
   public function doCommit($message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function amendCommit($message = null) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllBranches() {
     // TODO: Implement for Mercurial/SVN and make abstract.
     return array();
   }
 
   public function hasLocalCommit($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitMessage($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitSummary($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllLocalChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalBranchMerge();
 
   public function performLocalBranchMerge($branch, $message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getFinalizedRevisionMessage() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function execxLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolvex();
   }
 
   public function execManualLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolve();
   }
 
   public function execFutureLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args);
   }
 
   abstract protected function buildLocalFuture(array $argv);
 
   public function canStashChanges() {
     return false;
   }
 
   public function stashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function unstashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
 /* -(  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
    */
   public function readScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     if (!Filesystem::pathExists($full_path)) {
       return false;
     }
 
     try {
       $result = Filesystem::readFile($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return $result;
   }
 
 
   /**
    * 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
    */
   public function writeScratchFile($path, $data) {
     $dir = $this->getScratchFilePath('');
     if (!$dir) {
       return false;
     }
 
     if (!Filesystem::pathExists($dir)) {
       try {
         Filesystem::createDirectory($dir);
       } catch (Exception $ex) {
         return false;
       }
     }
 
     try {
       Filesystem::writeFile($this->getScratchFilePath($path), $data);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   public function removeScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     try {
       Filesystem::remove($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   public function getReadableScratchFilePath($path) {
     $full_path = $this->getScratchFilePath($path);
     if ($full_path) {
       return Filesystem::readablePath(
         $full_path,
         $this->getPath());
     } else {
       return false;
     }
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   public function getScratchFilePath($path) {
     $new_scratch_path  = Filesystem::resolvePath(
       'arc',
       $this->getMetadataPath());
 
     static $checked = false;
     if (!$checked) {
       $checked = true;
       $old_scratch_path = $this->getPath('.arc');
       // we only want to do the migration once
       // unfortunately, people have checked in .arc directories which
       // means that the old one may get recreated after we delete it
       if (Filesystem::pathExists($old_scratch_path) &&
           !Filesystem::pathExists($new_scratch_path)) {
         Filesystem::createDirectory($new_scratch_path);
         $existing_files = Filesystem::listDirectory($old_scratch_path, true);
         foreach ($existing_files as $file) {
           $new_path = Filesystem::resolvePath($file, $new_scratch_path);
           $old_path = Filesystem::resolvePath($file, $old_scratch_path);
           Filesystem::writeFile(
             $new_path,
             Filesystem::readFile($old_path));
         }
         Filesystem::remove($old_scratch_path);
       }
     }
     return Filesystem::resolvePath($path, $new_scratch_path);
   }
 
 
 /* -(  Base Commits  )------------------------------------------------------- */
 
   abstract public function supportsCommitRanges();
 
   final public function setBaseCommit($symbolic_commit) {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     $this->symbolicBaseCommit = $symbolic_commit;
     $this->reloadCommitRange();
     return $this;
   }
 
   public function setHeadCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   final public function getBaseCommit() {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     if ($this->resolvedBaseCommit === null) {
       $commit = $this->buildBaseCommit($this->symbolicBaseCommit);
       $this->resolvedBaseCommit = $commit;
     }
 
     return $this->resolvedBaseCommit;
   }
 
   public function getHeadCommit() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   final public function reloadCommitRange() {
     $this->resolvedBaseCommit = null;
     $this->baseCommitExplanation = null;
 
     $this->didReloadCommitRange();
 
     return $this;
   }
 
   protected function didReloadCommitRange() {
     return;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getBaseCommitExplanation() {
     return $this->baseCommitExplanation;
   }
 
   public function setBaseCommitExplanation($explanation) {
     $this->baseCommitExplanation = $explanation;
     return $this;
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     return null;
   }
 
   public function setBaseCommitArgumentRules($base_commit_argument_rules) {
     $this->baseCommitArgumentRules = $base_commit_argument_rules;
     return $this;
   }
 
   public function getBaseCommitArgumentRules() {
     return $this->baseCommitArgumentRules;
   }
 
   public function resolveBaseCommit() {
     $base_commit_rules = array(
       'runtime' => $this->getBaseCommitArgumentRules(),
       'local'   => '',
       'project' => '',
       'user'    => '',
       'system'  => '',
     );
     $all_sources = $this->configurationManager->getConfigFromAllSources('base');
 
     $base_commit_rules = $all_sources + $base_commit_rules;
 
     $parser = new ArcanistBaseCommitParser($this);
     $commit = $parser->resolveBaseCommit($base_commit_rules);
 
     return $commit;
   }
 
   public function getRepositoryUUID() {
     return null;
   }
 
 }
diff --git a/src/repository/api/ArcanistSubversionAPI.php b/src/repository/api/ArcanistSubversionAPI.php
index 1d2157e6..a4114bd0 100644
--- a/src/repository/api/ArcanistSubversionAPI.php
+++ b/src/repository/api/ArcanistSubversionAPI.php
@@ -1,695 +1,692 @@
 <?php
 
 /**
  * Interfaces with Subversion working copies.
- *
- * @group workingcopy
  */
 final class ArcanistSubversionAPI extends ArcanistRepositoryAPI {
 
   protected $svnStatus;
   protected $svnBaseRevisions;
   protected $svnInfo = array();
 
   protected $svnInfoRaw = array();
   protected $svnDiffRaw = array();
 
   private $svnBaseRevisionNumber;
   private $statusPaths = array();
 
   public function getSourceControlSystemName() {
     return 'svn';
   }
 
   public function getMetadataPath() {
     static $svn_dir = null;
     if ($svn_dir === null) {
       // from svn 1.7, subversion keeps a single .svn directly under
-      // the working copy root.  However, we allow .arcconfigs that
+      // the working copy root. However, we allow .arcconfigs that
       // aren't at the working copy root.
       foreach (Filesystem::walkToRoot($this->getPath()) as $parent) {
         $possible_svn_dir = Filesystem::resolvePath('.svn', $parent);
         if (Filesystem::pathExists($possible_svn_dir)) {
           $svn_dir = $possible_svn_dir;
           break;
         }
       }
     }
     return $svn_dir;
   }
 
   protected function buildLocalFuture(array $argv) {
 
     $argv[0] = 'svn '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   protected function buildCommitRangeStatus() {
     // In SVN, the commit range is always "uncommitted changes", so these
     // statuses are equivalent.
     return $this->getUncommittedStatus();
   }
 
   protected function buildUncommittedStatus() {
     return $this->getSVNStatus();
   }
 
   public function getSVNBaseRevisions() {
     if ($this->svnBaseRevisions === null) {
       $this->getSVNStatus();
     }
     return $this->svnBaseRevisions;
   }
 
   public function limitStatusToPaths(array $paths) {
     $this->statusPaths = $paths;
     return $this;
   }
 
   public function getSVNStatus($with_externals = false) {
     if ($this->svnStatus === null) {
       if ($this->statusPaths) {
         list($status) = $this->execxLocal(
           '--xml status %Ls',
           $this->statusPaths);
       } else {
         list($status) = $this->execxLocal('--xml status');
       }
       $xml = new SimpleXMLElement($status);
 
       $externals = array();
       $files = array();
 
       foreach ($xml->target as $target) {
         $this->svnBaseRevisions = array();
         foreach ($target->entry as $entry) {
           $path = (string)$entry['path'];
           // On Windows, we get paths with backslash directory separators here.
           // Normalize them to the format everything else expects and generates.
           if (phutil_is_windows()) {
             $path = str_replace(DIRECTORY_SEPARATOR, '/', $path);
           }
           $mask = 0;
 
           $props = (string)($entry->{'wc-status'}[0]['props']);
           $item  = (string)($entry->{'wc-status'}[0]['item']);
 
           $base = (string)($entry->{'wc-status'}[0]['revision']);
           $this->svnBaseRevisions[$path] = $base;
 
           switch ($props) {
             case 'none':
             case 'normal':
               break;
             case 'modified':
               $mask |= self::FLAG_MODIFIED;
               break;
             default:
               throw new Exception("Unrecognized property status '{$props}'.");
           }
 
           $mask |= $this->parseSVNStatus($item);
           if ($item == 'external') {
             $externals[] = $path;
           }
 
           // This is new in or around Subversion 1.6.
           $tree_conflicts = ($entry->{'wc-status'}[0]['tree-conflicted']);
           if ((string)$tree_conflicts) {
             $mask |= self::FLAG_CONFLICT;
           }
 
           $files[$path] = $mask;
         }
       }
 
       foreach ($files as $path => $mask) {
         foreach ($externals as $external) {
           if (!strncmp($path.'/', $external.'/', strlen($external) + 1)) {
             $files[$path] |= self::FLAG_EXTERNALS;
           }
         }
       }
 
       $this->svnStatus = $files;
     }
 
     $status = $this->svnStatus;
     if (!$with_externals) {
       foreach ($status as $path => $mask) {
         if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
           unset($status[$path]);
         }
       }
     }
 
     return $status;
   }
 
   private function parseSVNStatus($item) {
     switch ($item) {
       case 'none':
         // We can get 'none' for property changes on a directory.
       case 'normal':
         return 0;
       case 'external':
         return self::FLAG_EXTERNALS;
       case 'unversioned':
         return self::FLAG_UNTRACKED;
       case 'obstructed':
         return self::FLAG_OBSTRUCTED;
       case 'missing':
         return self::FLAG_MISSING;
       case 'added':
         return self::FLAG_ADDED;
       case 'replaced':
         // This is the result of "svn rm"-ing a file, putting another one
         // in place of it, and then "svn add"-ing the new file. Just treat
         // this as equivalent to "modified".
         return self::FLAG_MODIFIED;
       case 'modified':
         return self::FLAG_MODIFIED;
       case 'deleted':
         return self::FLAG_DELETED;
       case 'conflicted':
         return self::FLAG_CONFLICT;
       case 'incomplete':
         return self::FLAG_INCOMPLETE;
       default:
         throw new Exception("Unrecognized item status '{$item}'.");
     }
   }
 
   public function addToCommit(array $paths) {
     $add = array_filter($paths, 'Filesystem::pathExists');
     if ($add) {
       $this->execxLocal(
         'add -- %Ls',
         $add);
     }
     if ($add != $paths) {
       $this->execxLocal(
         'delete -- %Ls',
         array_diff($paths, $add));
     }
     $this->svnStatus = null;
   }
 
   public function getSVNProperty($path, $property) {
     list($stdout) = execx(
       'svn propget %s %s@',
       $property,
       $this->getPath($path));
     return trim($stdout);
   }
 
   public function getSourceControlPath() {
     return idx($this->getSVNInfo('/'), 'URL');
   }
 
   public function getSourceControlBaseRevision() {
     $info = $this->getSVNInfo('/');
     return $info['URL'].'@'.$this->getSVNBaseRevisionNumber();
   }
 
   public function getCanonicalRevisionName($string) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getSVNBaseRevisionNumber() {
     if ($this->svnBaseRevisionNumber) {
       return $this->svnBaseRevisionNumber;
     }
     $info = $this->getSVNInfo('/');
     return $info['Revision'];
   }
 
   public function overrideSVNBaseRevisionNumber($effective_base_revision) {
     $this->svnBaseRevisionNumber = $effective_base_revision;
     return $this;
   }
 
   public function getBranchName() {
     $info = $this->getSVNInfo('/');
     $repo_root = idx($info, 'Repository Root');
     $repo_root_length = strlen($repo_root);
     $url = idx($info, 'URL');
     if (substr($url, 0, $repo_root_length) == $repo_root) {
       return substr($url, $repo_root_length);
     }
     return 'svn';
   }
 
   public function getRemoteURI() {
     return idx($this->getSVNInfo('/'), 'Repository Root');
   }
 
   public function buildInfoFuture($path) {
     if ($path == '/') {
       // When the root of a working copy is referenced by a symlink and you
       // execute 'svn info' on that symlink, svn fails. This is a longstanding
       // bug in svn:
       //
       // See http://subversion.tigris.org/issues/show_bug.cgi?id=2305
       //
       // To reproduce, do:
       //
       //  $ ln -s working_copy working_link
       //  $ svn info working_copy # ok
       //  $ svn info working_link # fails
       //
       // Work around this by cd-ing into the directory before executing
       // 'svn info'.
       return $this->buildLocalFuture(array('info .'));
     } else {
       // Note: here and elsewhere we need to append "@" to the path because if
       // a file has a literal "@" in it, everything after that will be
       // interpreted as a revision. By appending "@" with no argument, SVN
       // parses it properly.
       return $this->buildLocalFuture(array('info %s@', $this->getPath($path)));
     }
   }
 
   public function buildDiffFuture($path) {
     // The "--depth empty" flag prevents us from picking up changes in
     // children when we run 'diff' against a directory. Specifically, when a
     // user has added or modified some directory "example/", we want to return
     // ONLY changes to that directory when given it as a path. If we run
     // without "--depth empty", svn will give us changes to the directory
     // itself (such as property changes) and also give us changes to any
     // files within the directory (basically, implicit recursion). We don't
     // want that, so prevent recursive diffing.
     $root = phutil_get_library_root('arcanist');
 
     if (phutil_is_windows()) {
       // TODO: Provide a binary_safe_diff script for Windows.
       // TODO: Provide a diff command which can take lines of context somehow.
       return $this->buildLocalFuture(
         array(
           'diff --depth empty %s',
           $path,
         ));
     } else {
       $diff_bin = $root.'/../scripts/repository/binary_safe_diff.sh';
       $diff_cmd = Filesystem::resolvePath($diff_bin);
       return $this->buildLocalFuture(
         array(
           'diff --depth empty --diff-cmd %s -x -U%d %s',
           $diff_cmd,
           $this->getDiffLinesOfContext(),
           $path,
         ));
     }
   }
 
   public function primeSVNInfoResult($path, $result) {
     $this->svnInfoRaw[$path] = $result;
     return $this;
   }
 
   public function primeSVNDiffResult($path, $result) {
     $this->svnDiffRaw[$path] = $result;
     return $this;
   }
 
   public function getSVNInfo($path) {
-
     if (empty($this->svnInfo[$path])) {
 
       if (empty($this->svnInfoRaw[$path])) {
         $this->svnInfoRaw[$path] = $this->buildInfoFuture($path)->resolve();
       }
 
       list($err, $stdout) = $this->svnInfoRaw[$path];
       if ($err) {
         throw new Exception(
           "Error #{$err} executing svn info against '{$path}'.");
       }
 
       // TODO: Hack for Windows.
       $stdout = str_replace("\r\n", "\n", $stdout);
 
       $patterns = array(
         '/^(URL): (\S+)$/m',
         '/^(Revision): (\d+)$/m',
         '/^(Last Changed Author): (\S+)$/m',
         '/^(Last Changed Rev): (\d+)$/m',
         '/^(Last Changed Date): (.+) \(.+\)$/m',
         '/^(Copied From URL): (\S+)$/m',
         '/^(Copied From Rev): (\d+)$/m',
         '/^(Repository Root): (\S+)$/m',
         '/^(Repository UUID): (\S+)$/m',
         '/^(Node Kind): (\S+)$/m',
       );
 
       $result = array();
       foreach ($patterns as $pattern) {
         $matches = null;
         if (preg_match($pattern, $stdout, $matches)) {
           $result[$matches[1]] = $matches[2];
         }
       }
 
       if (isset($result['Last Changed Date'])) {
         $result['Last Changed Date'] = strtotime($result['Last Changed Date']);
       }
 
       if (empty($result)) {
         throw new Exception('Unable to parse SVN info.');
       }
 
       $this->svnInfo[$path] = $result;
     }
 
     return $this->svnInfo[$path];
   }
 
 
   public function getRawDiffText($path) {
     $status = $this->getSVNStatus();
     if (!isset($status[$path])) {
       return null;
     }
 
     $status = $status[$path];
 
     // Build meaningful diff text for "svn copy" operations.
     if ($status & ArcanistRepositoryAPI::FLAG_ADDED) {
       $info = $this->getSVNInfo($path);
       if (!empty($info['Copied From URL'])) {
         return $this->buildSyntheticAdditionDiff(
           $path,
           $info['Copied From URL'],
           $info['Copied From Rev']);
       }
     }
 
     // If we run "diff" on a binary file which doesn't have the "svn:mime-type"
     // of "application/octet-stream", `diff' will explode in a rain of
     // unhelpful hellfire as it tries to build a textual diff of the two
     // files. We just fix this inline since it's pretty unambiguous.
     // TODO: Move this to configuration?
     $matches = null;
     if (preg_match('/\.(gif|png|jpe?g|swf|pdf|ico)$/i', $path, $matches)) {
       // Check if the file is deleted first; SVN will complain if we try to
       // get properties of a deleted file.
       if ($status & ArcanistRepositoryAPI::FLAG_DELETED) {
         return <<<EODIFF
 Index: {$path}
 ===================================================================
 Cannot display: file marked as a binary type.
 svn:mime-type = application/octet-stream
 
 EODIFF;
       }
 
       $mime = $this->getSVNProperty($path, 'svn:mime-type');
       if ($mime != 'application/octet-stream') {
         execx(
           'svn propset svn:mime-type application/octet-stream %s',
           self::escapeFileNameForSVN($this->getPath($path)));
       }
     }
 
     if (empty($this->svnDiffRaw[$path])) {
       $this->svnDiffRaw[$path] = $this->buildDiffFuture($path)->resolve();
     }
 
     list($err, $stdout, $stderr) = $this->svnDiffRaw[$path];
 
     // Note: GNU Diff returns 2 when SVN hands it binary files to diff and they
     // differ. This is not an error; it is documented behavior. But SVN isn't
     // happy about it. SVN will exit with code 1 and return the string below.
     if ($err != 0 && $stderr !== "svn: 'diff' returned 2\n") {
       throw new Exception(
         "svn diff returned unexpected error code: $err\n".
         "stdout: $stdout\n".
         "stderr: $stderr");
     }
 
     if ($err == 0 && empty($stdout)) {
       // If there are no changes, 'diff' exits with no output, but that means
       // we can not distinguish between empty and unmodified files. Build a
       // synthetic "diff" without any changes in it.
       return $this->buildSyntheticUnchangedDiff($path);
     }
 
     return $stdout;
   }
 
   protected function buildSyntheticAdditionDiff($path, $source, $rev) {
     $type = $this->getSVNProperty($path, 'svn:mime-type');
     if ($type == 'application/octet-stream') {
       return <<<EODIFF
 Index: {$path}
 ===================================================================
 Cannot display: file marked as a binary type.
 svn:mime-type = application/octet-stream
 
 EODIFF;
     }
 
     if (is_dir($this->getPath($path))) {
       return null;
     }
 
     $data = Filesystem::readFile($this->getPath($path));
     list($orig) = execx('svn cat %s@%s', $source, $rev);
 
     $src = new TempFile();
     $dst = new TempFile();
     Filesystem::writeFile($src, $orig);
     Filesystem::writeFile($dst, $data);
 
     list($err, $diff) = exec_manual(
       'diff -L a/%s -L b/%s -U%d %s %s',
       str_replace($this->getSourceControlPath().'/', '', $source),
       $path,
       $this->getDiffLinesOfContext(),
       $src,
       $dst);
 
     if ($err == 1) { // 1 means there are differences.
       return <<<EODIFF
 Index: {$path}
 ===================================================================
 {$diff}
 
 EODIFF;
     } else {
       return $this->buildSyntheticUnchangedDiff($path);
     }
   }
 
   protected function buildSyntheticUnchangedDiff($path) {
     $full_path = $this->getPath($path);
     if (is_dir($full_path)) {
       return null;
     }
 
     if (!file_exists($full_path)) {
       return null;
     }
 
     $data = Filesystem::readFile($full_path);
     $lines = explode("\n", $data);
     $len = count($lines);
     foreach ($lines as $key => $line) {
       $lines[$key] = ' '.$line;
     }
     $lines = implode("\n", $lines);
     return <<<EODIFF
 Index: {$path}
 ===================================================================
 --- {$path} (synthetic)
 +++ {$path} (synthetic)
 @@ -1,{$len} +1,{$len} @@
 {$lines}
 
 EODIFF;
   }
 
   public function getAllFiles() {
     // TODO: Handle paths with newlines.
     $future = $this->buildLocalFuture(array('list -R'));
     return new PhutilCallbackFilterIterator(
       new LinesOfALargeExecFuture($future),
       array($this, 'filterFiles'));
   }
 
   public function getChangedFiles($since_commit) {
     $url = '';
     $match = null;
     if (preg_match('/(.*)@(.*)/', $since_commit, $match)) {
       list(, $url, $since_commit) = $match;
     }
     // TODO: Handle paths with newlines.
     list($stdout) = $this->execxLocal(
       '--xml diff --revision %s:HEAD --summarize %s',
       $since_commit,
       $url);
     $xml = new SimpleXMLElement($stdout);
 
     $return = array();
     foreach ($xml->paths[0]->path as $path) {
       $return[(string)$path] = $this->parseSVNStatus($path['item']);
     }
     return $return;
   }
 
   public function filterFiles($path) {
     // NOTE: SVN uses '/' also on Windows.
     if ($path == '' || substr($path, -1) == '/') {
       return null;
     }
     return $path;
   }
 
   public function getBlame($path) {
     $blame = array();
 
     list($stdout) = $this->execxLocal('blame %s', $path);
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       // Empty file.
       return $blame;
     }
 
     foreach (explode("\n", $stdout) as $line) {
       $m = array();
       if (!preg_match('/^\s*(\d+)\s+(\S+)/', $line, $m)) {
         throw new Exception("Bad blame? `{$line}'");
       }
       $revision = $m[1];
       $author = $m[2];
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     // SVN issues warnings for nonexistent paths, directories, etc., but still
     // returns no error code. However, for new paths in the working copy it
     // fails. Assume that failure means the original file does not exist.
     list($err, $stdout) = $this->execManualLocal('cat %s@', $path);
     if ($err) {
       return null;
     }
     return $stdout;
   }
 
   public function getCurrentFileData($path) {
     $full_path = $this->getPath($path);
     if (Filesystem::pathExists($full_path)) {
       return Filesystem::readFile($full_path);
     }
     return null;
   }
 
   public function getRepositoryUUID() {
     $info = $this->getSVNInfo('/');
     return $info['Repository UUID'];
   }
 
   public function getLocalCommitInformation() {
     return null;
   }
 
   public function isHistoryDefaultImmutable() {
     return true;
   }
 
   public function supportsAmend() {
     return false;
   }
 
   public function supportsCommitRanges() {
     return false;
   }
 
   public function supportsLocalCommits() {
     return false;
   }
 
   public function hasLocalCommit($commit) {
     return false;
   }
 
   public function getWorkingCopyRevision() {
     return $this->getSourceControlBaseRevision();
   }
 
   public function supportsLocalBranchMerge() {
     return false;
   }
 
   public function getFinalizedRevisionMessage() {
     // In other VCSes we give push instructions here, but it never makes sense
     // in SVN.
     return 'Done.';
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     // We don't have much to go on in SVN, look for revisions that came from
     // this directory and belong to the same project.
 
     $project = $this->getWorkingCopyIdentity()->getProjectID();
     if (!$project) {
       return array();
     }
 
     $results = $conduit->callMethodSynchronous(
       'differential.query',
       $query + array(
         'arcanistProjects' => array($project),
       ));
 
     foreach ($results as $key => $result) {
       if ($result['sourcePath'] != $this->getPath()) {
         unset($results[$key]);
       }
     }
 
     foreach ($results as $key => $result) {
       $results[$key]['why'] =
         'Matching arcanist project name and working copy directory path.';
     }
 
     return $results;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('up');
   }
 
   public static function escapeFileNamesForSVN(array $files) {
     foreach ($files as $k => $file) {
       $files[$k] = self::escapeFileNameForSVN($file);
     }
     return $files;
   }
 
   public static function escapeFileNameForSVN($file) {
     // SVN interprets "x@1" as meaning "file x at revision 1", which is not
     // intended for files named "sprite@2x.png" or similar. For files with an
     // "@" in their names, escape them by adding "@" at the end, which SVN
     // interprets as "at the working copy revision". There is a special case
     // where ".@" means "fail with an error" instead of ". at the working copy
     // revision", so avoid escaping "." into ".@".
 
     if (strpos($file, '@') !== false) {
       $file = $file.'@';
     }
 
     return $file;
   }
 
 }
diff --git a/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php b/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php
index d349d5e5..ed13af09 100644
--- a/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php
+++ b/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php
@@ -1,124 +1,123 @@
 <?php
 
 final class ArcanistRepositoryAPIStateTestCase extends ArcanistTestCase {
 
   public function testGitStateParsing() {
     if (Filesystem::binaryExists('git')) {
       $this->parseState('git_basic.git.tgz');
     } else {
       $this->assertSkipped('Git is not installed');
     }
   }
 
   public function testHgStateParsing() {
     if (Filesystem::binaryExists('hg')) {
       $this->parseState('hg_basic.hg.tgz');
     } else {
       $this->assertSkipped('Mercurial is not installed');
     }
   }
 
   public function testSvnStateParsing() {
     if (Filesystem::binaryExists('svn')) {
       $this->parseState('svn_basic.svn.tgz');
     } else {
       $this->assertSkipped('Subversion is not installed');
     }
   }
 
   private function parseState($test) {
     $dir = dirname(__FILE__).'/state/';
     $fixture = PhutilDirectoryFixture::newFromArchive($dir.'/'.$test);
 
     $fixture_path = $fixture->getPath();
     $working_copy = ArcanistWorkingCopyIdentity::newFromPath($fixture_path);
     $configuration_manager = new ArcanistConfigurationManager();
     $configuration_manager->setWorkingCopyIdentity($working_copy);
     $api = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
       $configuration_manager);
 
     $api->setBaseCommitArgumentRules('arc:this');
 
     if ($api instanceof ArcanistSubversionAPI) {
       // Upgrade the repository so that the test will still pass if the local
       // `svn` is newer than the `svn` which created the repository.
 
       // NOTE: Some versions of Subversion (1.7.x?) exit with an error code on
       // a no-op upgrade, although newer versions do not. We just ignore the
       // error here; if it's because of an actual problem we'll hit an error
       // shortly anyway.
       $api->execManualLocal('upgrade');
     }
 
     $this->assertCorrectState($test, $api);
   }
 
   private function assertCorrectState($test, ArcanistRepositoryAPI $api) {
     $f_mod = ArcanistRepositoryAPI::FLAG_MODIFIED;
     $f_add = ArcanistRepositoryAPI::FLAG_ADDED;
     $f_del = ArcanistRepositoryAPI::FLAG_DELETED;
     $f_unt = ArcanistRepositoryAPI::FLAG_UNTRACKED;
     $f_con = ArcanistRepositoryAPI::FLAG_CONFLICT;
     $f_mis = ArcanistRepositoryAPI::FLAG_MISSING;
     $f_uns = ArcanistRepositoryAPI::FLAG_UNSTAGED;
     $f_unc = ArcanistRepositoryAPI::FLAG_UNCOMMITTED;
     $f_ext = ArcanistRepositoryAPI::FLAG_EXTERNALS;
     $f_obs = ArcanistRepositoryAPI::FLAG_OBSTRUCTED;
     $f_inc = ArcanistRepositoryAPI::FLAG_INCOMPLETE;
 
     switch ($test) {
       case 'svn_basic.svn.tgz':
         $expect = array(
           'ADDED'       => $f_add,
           'COPIED_TO'   => $f_add,
           'DELETED'     => $f_del,
           'MODIFIED'    => $f_mod,
           'MOVED'       => $f_del,
           'MOVED_TO'    => $f_add,
           'PROPCHANGE'  => $f_mod,
           'UNTRACKED'   => $f_unt,
         );
         $this->assertEqual($expect, $api->getUncommittedStatus());
         $this->assertEqual($expect, $api->getCommitRangeStatus());
         break;
       case 'git_basic.git.tgz':
         $expect_uncommitted = array(
           'UNCOMMITTED' => $f_add | $f_unc,
           'UNSTAGED'    => $f_mod | $f_uns | $f_unc,
           'UNTRACKED'   => $f_unt,
         );
 
         $this->assertEqual($expect_uncommitted, $api->getUncommittedStatus());
 
         $expect_range = array(
           'ADDED'       => $f_add,
           'DELETED'     => $f_del,
           'MODIFIED'    => $f_mod,
           'UNCOMMITTED' => $f_add,
           'UNSTAGED'    => $f_add,
         );
         $this->assertEqual($expect_range, $api->getCommitRangeStatus());
         break;
       case 'hg_basic.hg.tgz':
         $expect_uncommitted = array(
           'UNCOMMITTED' => $f_mod | $f_unc,
           'UNTRACKED'   => $f_unt,
         );
         $this->assertEqual($expect_uncommitted, $api->getUncommittedStatus());
 
         $expect_range = array(
           'ADDED'       => $f_add,
           'DELETED'     => $f_del,
           'MODIFIED'    => $f_mod,
           'UNCOMMITTED' => $f_add,
         );
         $this->assertEqual($expect_range, $api->getCommitRangeStatus());
         break;
       default:
         throw new Exception(
           "No test cases for working copy '{$test}'!");
     }
   }
 
-
 }
diff --git a/src/repository/hookapi/ArcanistHookAPI.php b/src/repository/hookapi/ArcanistHookAPI.php
index 7c461a31..2c9a217f 100644
--- a/src/repository/hookapi/ArcanistHookAPI.php
+++ b/src/repository/hookapi/ArcanistHookAPI.php
@@ -1,9 +1,9 @@
 <?php
 
 /**
- * API while running in the context of a commit hook
+ * API while running in the context of a commit hook.
  */
 abstract class ArcanistHookAPI {
   abstract public function getCurrentFileData($path);
   abstract public function getUpstreamFileData($path);
 }
diff --git a/src/repository/hookapi/ArcanistSubversionHookAPI.php b/src/repository/hookapi/ArcanistSubversionHookAPI.php
index acefff2b..95b80c8c 100644
--- a/src/repository/hookapi/ArcanistSubversionHookAPI.php
+++ b/src/repository/hookapi/ArcanistSubversionHookAPI.php
@@ -1,35 +1,36 @@
 <?php
 
 /**
  * Interfaces with Subversion while running as a commit hook.
  */
 final class ArcanistSubversionHookAPI extends ArcanistHookAPI {
 
   protected $root;
   protected $transaction;
   protected $repository;
 
   public function __construct($root, $transaction, $repository) {
     $this->root        = $root;
     $this->transaction = $transaction;
     $this->repository  = $repository;
   }
 
   public function getCurrentFileData($path) {
     list($err, $file) = exec_manual(
       'svnlook cat --transaction %s %s %s',
       $this->transaction,
       $this->repository,
       $path);
 
     return ($err? null : $file);
   }
 
   public function getUpstreamFileData($path) {
     list($err, $file) = exec_manual(
       'svnlook cat %s %s',
       $this->repository,
       $this->root."/$path");
     return ($err ? null : $file);
   }
+
 }
diff --git a/src/repository/parser/ArcanistMercurialParser.php b/src/repository/parser/ArcanistMercurialParser.php
index 62df7789..d5d2bf13 100644
--- a/src/repository/parser/ArcanistMercurialParser.php
+++ b/src/repository/parser/ArcanistMercurialParser.php
@@ -1,226 +1,225 @@
 <?php
 
 /**
  * Parses output from various "hg" commands into structured data. This class
  * provides low-level APIs for reading "hg" output.
  *
  * @task  parse Parsing "hg" Output
- * @group workingcopy
  */
 final class ArcanistMercurialParser {
 
 
 /* -(  Parsing "hg" Output  )------------------------------------------------ */
 
 
   /**
    * Parse the output of "hg status". This provides detailed information, you
    * can get less detailed information with @{method:parseMercurialStatus}. In
    * particular, this will parse copy sources as per "hg status -C".
    *
    * @param string The stdout from running an "hg status" command.
    * @return dict Map of paths to status dictionaries.
    * @task parse
    */
   public static function parseMercurialStatusDetails($stdout) {
     $result = array();
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       return $result;
     }
 
     $last_path = null;
     $lines = explode("\n", $stdout);
     foreach ($lines as $line) {
       $flags = 0;
       if ($line[1] !== ' ') {
         throw new Exception("Unparsable Mercurial status line '{$line}'.");
       }
       $code = $line[0];
       $path = substr($line, 2);
       switch ($code) {
         case 'A':
           $flags |= ArcanistRepositoryAPI::FLAG_ADDED;
           break;
         case 'R':
           $flags |= ArcanistRepositoryAPI::FLAG_DELETED;
           break;
         case 'M':
           $flags |= ArcanistRepositoryAPI::FLAG_MODIFIED;
           break;
         case 'C':
           // This is "clean" and included only for completeness, these files
           // have not been changed.
           break;
         case '!':
           $flags |= ArcanistRepositoryAPI::FLAG_MISSING;
           break;
         case '?':
           $flags |= ArcanistRepositoryAPI::FLAG_UNTRACKED;
           break;
         case 'I':
           // This is "ignored" and included only for completeness.
           break;
         case ' ':
           // This shows the source of a file move, so update the last file we
           // parsed to set its source.
           if ($last_path === null) {
             throw new Exception(
               "Unexpected copy source in hg status, '{$line}'.");
           }
           $result[$last_path]['from'] = $path;
           continue 2;
         default:
           throw new Exception("Unknown Mercurial status '{$code}'.");
       }
 
       $result[$path] = array(
         'flags' => $flags,
         'from'  => null,
       );
       $last_path = $path;
     }
 
     return $result;
   }
 
 
   /**
    * Parse the output of "hg status". This provides only basic information, you
    * can get more detailed information by invoking
    * @{method:parseMercurialStatusDetails}.
    *
    * @param string The stdout from running an "hg status" command.
    * @return dict Map of paths to ArcanistRepositoryAPI status flags.
    * @task parse
    */
   public static function parseMercurialStatus($stdout) {
     $result = self::parseMercurialStatusDetails($stdout);
     return ipull($result, 'flags');
   }
 
 
   /**
    * Parse the output of "hg log". This also parses "hg outgoing", "hg parents",
    * and other similar commands. This assumes "--style default".
    *
    * @param string The stdout from running an "hg log" command.
    * @return list List of dictionaries with commit information.
    * @task parse
    */
   public static function parseMercurialLog($stdout) {
     $result = array();
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       return $result;
     }
 
     $chunks = explode("\n\n", $stdout);
     foreach ($chunks as $chunk) {
       $commit = array();
       $lines = explode("\n", $chunk);
       foreach ($lines as $line) {
         if (preg_match('/^(comparing with|searching for changes)/', $line)) {
           // These are sent to stdout when you run "hg outgoing" although the
           // format is otherwise identical to "hg log".
           continue;
         }
 
         if (preg_match('/^remote:/', $line)) {
           // This indicates remote error in "hg outgoing".
           continue;
         }
 
         list($name, $value) = explode(':', $line, 2);
         $value = trim($value);
         switch ($name) {
           case 'user':
             $commit['user'] = $value;
             break;
           case 'date':
             $commit['date'] = strtotime($value);
             break;
           case 'summary':
             $commit['summary'] = $value;
             break;
           case 'changeset':
             list($local, $rev) = explode(':', $value, 2);
             $commit['local'] = $local;
             $commit['rev'] = $rev;
             break;
           case 'parent':
             if (empty($commit['parents'])) {
               $commit['parents'] = array();
             }
             list($local, $rev) = explode(':', $value, 2);
             $commit['parents'][] = array(
               'local' => $local,
               'rev'   => $rev,
             );
             break;
           case 'branch':
             $commit['branch'] = $value;
             break;
           case 'tag':
             $commit['tag'] = $value;
             break;
           case 'bookmark':
             $commit['bookmark'] = $value;
             break;
           default:
             throw new Exception("Unknown Mercurial log field '{$name}'!");
         }
       }
       $result[] = $commit;
     }
 
     return $result;
   }
 
 
   /**
    * Parse the output of "hg branches".
    *
    * @param string The stdout from running an "hg branches" command.
    * @return list A list of dictionaries with branch information.
    * @task parse
    */
   public static function parseMercurialBranches($stdout) {
     $stdout = rtrim($stdout, "\n");
     if (!strlen($stdout)) {
       // No branches; commonly, this occurs in a newly initialized repository.
       return array();
     }
 
     $lines = explode("\n", $stdout);
 
     $branches = array();
     foreach ($lines as $line) {
       $matches = null;
 
       // Output of "hg branches" normally looks like:
       //
       //  default                    15101:a21ccf4412d5
       //
       // ...but may also have human-readable cues like:
       //
       //  stable                     15095:ec222a29bdf0 (inactive)
       //
       // See the unit tests for more examples.
       $regexp = '/^(\S+(?:\s+\S+)*)\s+(\d+):([a-f0-9]+)(\s+\\(inactive\\))?$/';
 
       if (!preg_match($regexp, $line, $matches)) {
         throw new Exception("Failed to parse 'hg branches' output: {$line}");
       }
       $branches[$matches[1]] = array(
         'local'   => $matches[2],
         'rev'     => $matches[3],
       );
     }
 
     return $branches;
   }
 
 }
diff --git a/src/repository/parser/__tests__/ArcanistMercurialParserTestCase.php b/src/repository/parser/__tests__/ArcanistMercurialParserTestCase.php
index 8e199669..2129448d 100644
--- a/src/repository/parser/__tests__/ArcanistMercurialParserTestCase.php
+++ b/src/repository/parser/__tests__/ArcanistMercurialParserTestCase.php
@@ -1,88 +1,89 @@
 <?php
 
 final class ArcanistMercurialParserTestCase extends ArcanistTestCase {
 
   public function testParseAll() {
     $root = dirname(__FILE__).'/mercurial/';
     foreach (Filesystem::listDirectory($root, $hidden = false) as $file) {
       $this->parseData(
         basename($file),
         Filesystem::readFile($root.'/'.$file));
     }
   }
 
   private function parseData($name, $data) {
     switch ($name) {
       case 'branches-basic.txt':
         $output = ArcanistMercurialParser::parseMercurialBranches($data);
         $this->assertEqual(
           array('default', 'stable'),
           array_keys($output));
         $this->assertEqual(
           array('a21ccf4412d5', 'ec222a29bdf0'),
           array_values(ipull($output, 'rev')));
         break;
       case 'branches-with-spaces.txt':
         $output = ArcanistMercurialParser::parseMercurialBranches($data);
         $this->assertEqual(
           array(
             'm m m m m 2:ffffffffffff (inactive)',
             'xxx yyy zzz',
             'default',
             "'",
           ),
           array_keys($output));
         $this->assertEqual(
           array('0b9d8290c4e0', '78963faacfc7', '5db03c5500c6', 'ffffffffffff'),
           array_values(ipull($output, 'rev')));
         break;
       case 'branches-empty.txt':
         $output = ArcanistMercurialParser::parseMercurialBranches($data);
         $this->assertEqual(array(), $output);
         break;
       case 'log-basic.txt':
         $output = ArcanistMercurialParser::parseMercurialLog($data);
         $this->assertEqual(
           3,
           count($output));
         $this->assertEqual(
           array('a21ccf4412d5', 'a051f8a6a7cc', 'b1f49efeab65'),
           array_values(ipull($output, 'rev')));
         break;
       case 'log-empty.txt':
         // Empty logs (e.g., "hg parents" for a root revision) should parse
         // correctly.
         $output = ArcanistMercurialParser::parseMercurialLog($data);
         $this->assertEqual(
           array(),
           $output);
         break;
       case 'status-basic.txt':
         $output = ArcanistMercurialParser::parseMercurialStatus($data);
         $this->assertEqual(
           4,
           count($output));
         $this->assertEqual(
           array('changed', 'added', 'removed', 'untracked'),
           array_keys($output));
         break;
       case 'status-moves.txt':
         $output = ArcanistMercurialParser::parseMercurialStatusDetails($data);
         $this->assertEqual(
           'move_source',
           $output['moved_file']['from']);
         $this->assertEqual(
           null,
           $output['changed_file']['from']);
         $this->assertEqual(
           'copy_source',
           $output['copied_file']['from']);
         $this->assertEqual(
           null,
           idx($output, 'copy_source'));
         break;
       default:
         throw new Exception("No test information for test data '{$name}'!");
     }
   }
+
 }
diff --git a/src/unit/ArcanistUnitTestResult.php b/src/unit/ArcanistUnitTestResult.php
index a1cd34a8..9628b591 100644
--- a/src/unit/ArcanistUnitTestResult.php
+++ b/src/unit/ArcanistUnitTestResult.php
@@ -1,137 +1,135 @@
 <?php
 
 /**
  * Represents the outcome of running a unit test.
- *
- * @group unit
  */
 final class ArcanistUnitTestResult {
 
   const RESULT_PASS         = 'pass';
   const RESULT_FAIL         = 'fail';
   const RESULT_SKIP         = 'skip';
   const RESULT_BROKEN       = 'broken';
   const RESULT_UNSOUND      = 'unsound';
   const RESULT_POSTPONED    = 'postponed';
 
   private $namespace;
   private $name;
   private $link;
   private $result;
   private $duration;
   private $userData;
   private $extraData;
   private $coverage;
 
   public function setNamespace($namespace) {
     $this->namespace = $namespace;
     return $this;
   }
 
   public function getNamespace() {
     return $this->namespace;
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function setLink($link) {
     $this->link = $link;
     return $this;
   }
 
   public function getLink() {
     return $this->link;
   }
 
   public function setResult($result) {
     $this->result = $result;
     return $this;
   }
 
   public function getResult() {
     return $this->result;
   }
 
   public function setDuration($duration) {
     $this->duration = $duration;
     return $this;
   }
 
   public function getDuration() {
     return $this->duration;
   }
 
   public function setUserData($user_data) {
     $this->userData = $user_data;
     return $this;
   }
 
   public function getUserData() {
     return $this->userData;
   }
 
   /**
-   * "extra data" allows an implementation to store additional
-   * key/value metadata along with the result of the test run.
+   * "extra data" allows an implementation to store additional key/value
+   * metadata along with the result of the test run.
    */
   public function setExtraData(array $extra_data = null) {
     $this->extraData = $extra_data;
     return $this;
   }
 
   public function getExtraData() {
     return $this->extraData;
   }
 
   public function setCoverage($coverage) {
     $this->coverage = $coverage;
     return $this;
   }
 
   public function getCoverage() {
     return $this->coverage;
   }
 
   /**
    * Merge several coverage reports into a comprehensive coverage report.
    *
    * @param list List of coverage report strings.
    * @return string Cumulative coverage report.
    */
   public static function mergeCoverage(array $coverage) {
     if (empty($coverage)) {
       return null;
     }
 
     $base = reset($coverage);
     foreach ($coverage as $more_coverage) {
       $len = min(strlen($base), strlen($more_coverage));
       for ($ii = 0; $ii < $len; $ii++) {
         if ($more_coverage[$ii] == 'C') {
           $base[$ii] = 'C';
         }
       }
     }
     return $base;
   }
 
   public function toDictionary() {
     return array(
       'name' => $this->getName(),
       'link' => $this->getLink(),
       'result' => $this->getResult(),
       'duration' => $this->getDuration(),
       'extra' => $this->getExtraData(),
       'userData' => $this->getUserData(),
       'coverage' => $this->getCoverage(),
     );
   }
 
 }
diff --git a/src/unit/engine/ArcanistBaseTestResultParser.php b/src/unit/engine/ArcanistBaseTestResultParser.php
index d10fe123..09233f90 100644
--- a/src/unit/engine/ArcanistBaseTestResultParser.php
+++ b/src/unit/engine/ArcanistBaseTestResultParser.php
@@ -1,52 +1,49 @@
 <?php
 
 /**
- * Abstract Base class for test result parsers
+ * Abstract Base class for test result parsers.
  */
 abstract class ArcanistBaseTestResultParser {
 
   protected $enableCoverage;
   protected $projectRoot;
   protected $coverageFile;
   protected $stderr;
 
   public function setEnableCoverage($enable_coverage) {
     $this->enableCoverage = $enable_coverage;
-
     return $this;
   }
 
   public function setProjectRoot($project_root) {
     $this->projectRoot = $project_root;
-
     return $this;
   }
 
   public function setCoverageFile($coverage_file) {
     $this->coverageFile = $coverage_file;
-
     return $this;
   }
 
   public function setAffectedTests($affected_tests) {
     $this->affectedTests = $affected_tests;
-
     return $this;
   }
 
   public function setStderr($stderr) {
     $this->stderr = $stderr;
     return $this;
   }
 
   /**
    * Parse test results from provided input and return an array
    * of ArcanistUnitTestResult
    *
    * @param string $path Path to test
    * @param string $test_results String containing test results
    *
    * @return array ArcanistUnitTestResult
    */
   abstract public function parseTestResults($path, $test_results);
+
 }
diff --git a/src/unit/engine/ArcanistBaseUnitTestEngine.php b/src/unit/engine/ArcanistBaseUnitTestEngine.php
index 9f3ae5e2..be31b25e 100644
--- a/src/unit/engine/ArcanistBaseUnitTestEngine.php
+++ b/src/unit/engine/ArcanistBaseUnitTestEngine.php
@@ -1,116 +1,115 @@
 <?php
 
 /**
  * Manages unit test execution.
- *
- * @group unit
  */
 abstract class ArcanistBaseUnitTestEngine {
 
   private $workingCopy;
   private $paths;
   private $arguments = array();
   protected $diffID;
   private $enableAsyncTests;
   private $enableCoverage;
   private $runAllTests;
   protected $renderer;
 
 
   public function setRunAllTests($run_all_tests) {
     if (!$this->supportsRunAllTests() && $run_all_tests) {
       $class = get_class($this);
       throw new Exception(
         "Engine '{$class}' does not support --everything.");
     }
 
     $this->runAllTests = $run_all_tests;
     return $this;
   }
 
   public function getRunAllTests() {
     return $this->runAllTests;
   }
 
   protected function supportsRunAllTests() {
     return false;
   }
 
   final public function __construct() {
 
   }
 
   public function setConfigurationManager(
     ArcanistConfigurationManager $configuration_manager) {
     $this->configurationManager = $configuration_manager;
     return $this;
   }
 
   public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   final public function setWorkingCopy(
     ArcanistWorkingCopyIdentity $working_copy) {
 
     $this->workingCopy = $working_copy;
     return $this;
   }
 
   final public function getWorkingCopy() {
     return $this->workingCopy;
   }
 
   final public function setPaths(array $paths) {
     $this->paths = $paths;
     return $this;
   }
 
   final public function getPaths() {
     return $this->paths;
   }
 
   final public function setArguments(array $arguments) {
     $this->arguments = $arguments;
     return $this;
   }
 
   final public function getArgument($key, $default = null) {
     return idx($this->arguments, $key, $default);
   }
 
   final public function setEnableAsyncTests($enable_async_tests) {
     $this->enableAsyncTests = $enable_async_tests;
     return $this;
   }
 
   final public function getEnableAsyncTests() {
     return $this->enableAsyncTests;
   }
 
   final public function setEnableCoverage($enable_coverage) {
     $this->enableCoverage = $enable_coverage;
     return $this;
   }
 
   final public function getEnableCoverage() {
     return $this->enableCoverage;
   }
 
   public function setRenderer(ArcanistUnitRenderer $renderer) {
     $this->renderer = $renderer;
     return $this;
   }
 
   abstract public function run();
 
   /**
-   * Modify the return value of this function in the child class, if
-   * you do not need to echo the test results after all the tests have
-   * been run. This is the case for example when the child class
-   * prints the tests results while the tests are running.
+   * Modify the return value of this function in the child class, if you do
+   * not need to echo the test results after all the tests have been run. This
+   * is the case for example when the child class prints the tests results
+   * while the tests are running.
    */
   public function shouldEchoTestResults() {
     return true;
   }
+
 }
diff --git a/src/unit/engine/ArcanistXUnitTestResultParser.php b/src/unit/engine/ArcanistXUnitTestResultParser.php
index 4c75b7e6..d8649172 100644
--- a/src/unit/engine/ArcanistXUnitTestResultParser.php
+++ b/src/unit/engine/ArcanistXUnitTestResultParser.php
@@ -1,96 +1,93 @@
 <?php
 
 /**
  * Parser for JUnit, NUnit, etc results format - https://gist.github.com/959290
- *
- * @group unitrun
  */
 final class ArcanistXUnitTestResultParser {
 
   /**
    * Parse test results from provided input and return an array
-   * of ArcanistUnitTestResult
+   * of @{class:ArcanistUnitTestResult}.
    *
    * @param string $test_results String containing test results
    *
    * @return array ArcanistUnitTestResult
    */
   public function parseTestResults($test_results) {
     if (!strlen($test_results)) {
       throw new Exception(
         'test_results argument to parseTestResults must not be empty');
     }
 
     // xunit xsd: https://gist.github.com/959290
     $xunit_dom = new DOMDocument();
     $load_success = @$xunit_dom->loadXML($test_results);
 
     if (!$load_success) {
       $input_start = phutil_utf8_shorten($test_results, 150);
       throw new Exception(
         "Failed to load XUnit report; Input starts with:\n\n {$input_start}");
     }
 
     $results = array();
     $testcases = $xunit_dom->getElementsByTagName('testcase');
     foreach ($testcases as $testcase) {
       $classname = $testcase->getAttribute('classname');
       $name = $testcase->getAttribute('name');
       $time = $testcase->getAttribute('time');
 
       $status = ArcanistUnitTestResult::RESULT_PASS;
       $user_data = '';
 
       // A skipped test is a test which was ignored using framework
-      // mechanizms (e.g. @skip decorator)
+      // mechanisms (e.g. @skip decorator)
       $skipped = $testcase->getElementsByTagName('skipped');
       if ($skipped->length > 0) {
         $status = ArcanistUnitTestResult::RESULT_SKIP;
         $messages = array();
         for ($ii = 0; $ii < $skipped->length; $ii++) {
           $messages[] = trim($skipped->item($ii)->nodeValue, " \n");
         }
 
         $user_data .= implode("\n", $messages);
       }
 
       // Failure is a test which the code has explicitly failed by using
-      // the mechanizms for that purpose. e.g., via an assertEquals
+      // the mechanisms for that purpose. e.g., via an assertEquals
       $failures = $testcase->getElementsByTagName('failure');
       if ($failures->length > 0) {
         $status = ArcanistUnitTestResult::RESULT_FAIL;
         $messages = array();
         for ($ii = 0; $ii < $failures->length; $ii++) {
           $messages[] = trim($failures->item($ii)->nodeValue, " \n");
         }
 
         $user_data .= implode("\n", $messages)."\n";
       }
 
       // An errored test is one that had an unanticipated problem. e.g., an
-      // unchecked throwable, or a problem with an implementation of the
-      // test.
+      // unchecked throwable, or a problem with an implementation of the test.
       $errors = $testcase->getElementsByTagName('error');
       if ($errors->length > 0) {
         $status = ArcanistUnitTestResult::RESULT_BROKEN;
         $messages = array();
         for ($ii = 0; $ii < $errors->length; $ii++) {
           $messages[] = trim($errors->item($ii)->nodeValue, " \n");
         }
 
         $user_data .= implode("\n", $messages)."\n";
       }
 
       $result = new ArcanistUnitTestResult();
       $result->setName($classname.'.'.$name);
       $result->setResult($status);
       $result->setDuration($time);
       $result->setUserData($user_data);
 
       $results[] = $result;
     }
 
     return $results;
   }
 
 }
diff --git a/src/unit/engine/CSharpToolsTestEngine.php b/src/unit/engine/CSharpToolsTestEngine.php
index f39e9796..aec00c73 100644
--- a/src/unit/engine/CSharpToolsTestEngine.php
+++ b/src/unit/engine/CSharpToolsTestEngine.php
@@ -1,286 +1,280 @@
 <?php
 
 /**
  * Uses cscover (http://github.com/hach-que/cstools) to report code coverage.
  *
  * This engine inherits from `XUnitTestEngine`, where xUnit is used to actually
  * run the unit tests and this class provides a thin layer on top to collect
  * code coverage data with a third-party tool.
- *
- * @group unitrun
  */
-
 final class CSharpToolsTestEngine extends XUnitTestEngine {
 
   private $cscoverHintPath;
   private $coverEngine;
   private $cachedResults;
   private $matchRegex;
   private $excludedFiles;
 
   /**
-   * Overridden version of `loadEnvironment` to support a different set
-   * of configuration values and to pull in the cstools config for
-   * code coverage.
+   * Overridden version of `loadEnvironment` to support a different set of
+   * configuration values and to pull in the cstools config for code coverage.
    */
   protected function loadEnvironment() {
-
     $config = $this->getConfigurationManager();
-    $this->cscoverHintPath =
-      $config->getConfigFromAnySource('unit.csharp.cscover.binary');
-    $this->matchRegex =
-      $config->getConfigFromAnySource('unit.csharp.coverage.match');
-    $this->excludedFiles =
-      $config->getConfigFromAnySource('unit.csharp.coverage.excluded');
+    $this->cscoverHintPath = $config->getConfigFromAnySource(
+      'unit.csharp.cscover.binary');
+    $this->matchRegex = $config->getConfigFromAnySource(
+      'unit.csharp.coverage.match');
+    $this->excludedFiles = $config->getConfigFromAnySource(
+      'unit.csharp.coverage.excluded');
 
     parent::loadEnvironment();
 
     if ($this->getEnableCoverage() === false) {
       return;
     }
 
     // Determine coverage path.
     if ($this->cscoverHintPath === null) {
       throw new Exception(
-        "Unable to locate cscover.  Configure it with ".
+        "Unable to locate cscover. Configure it with ".
         "the `unit.csharp.coverage.binary' option in .arcconfig");
     }
     $cscover = $this->projectRoot.DIRECTORY_SEPARATOR.$this->cscoverHintPath;
     if (file_exists($cscover)) {
       $this->coverEngine = Filesystem::resolvePath($cscover);
     } else {
       throw new Exception(
-        'Unable to locate cscover coverage runner '.
-        '(have you built yet?)');
+        'Unable to locate cscover coverage runner (have you built yet?)');
     }
-
   }
 
   /**
    * Returns whether the specified assembly should be instrumented for
-   * code coverage reporting.  Checks the excluded file list and the
+   * code coverage reporting. Checks the excluded file list and the
    * matching regex if they are configured.
    *
    * @return boolean Whether the assembly should be instrumented.
    */
   private function assemblyShouldBeInstrumented($file) {
     if ($this->excludedFiles !== null) {
       if (array_key_exists((string)$file, $this->excludedFiles)) {
         return false;
       }
     }
     if ($this->matchRegex !== null) {
       if (preg_match($this->matchRegex, $file) === 1) {
         return true;
       } else {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Overridden version of `buildTestFuture` so that the unit test can be run
    * via `cscover`, which instruments assemblies and reports on code coverage.
    *
    * @param  string  Name of the test assembly.
    * @return array   The future, output filename and coverage filename
    *                 stored in an array.
    */
   protected function buildTestFuture($test_assembly) {
     if ($this->getEnableCoverage() === false) {
       return parent::buildTestFuture($test_assembly);
     }
 
     // FIXME: Can't use TempFile here as xUnit doesn't like
-    // UNIX-style full paths.  It sees the leading / as the
+    // UNIX-style full paths. It sees the leading / as the
     // start of an option flag, even when quoted.
     $xunit_temp = Filesystem::readRandomCharacters(10).'.results.xml';
     if (file_exists($xunit_temp)) {
       unlink($xunit_temp);
     }
     $cover_temp = new TempFile();
     $cover_temp->setPreserveFile(true);
     $xunit_cmd = $this->runtimeEngine;
     $xunit_args = null;
     if ($xunit_cmd === '') {
       $xunit_cmd = $this->testEngine;
       $xunit_args = csprintf(
         '%s /xml %s',
         $test_assembly,
         $xunit_temp);
     } else {
       $xunit_args = csprintf(
         '%s %s /xml %s',
         $this->testEngine,
         $test_assembly,
         $xunit_temp);
     }
     $assembly_dir = dirname($test_assembly);
     $assemblies_to_instrument = array();
     foreach (Filesystem::listDirectory($assembly_dir) as $file) {
       if (substr($file, -4) == '.dll' || substr($file, -4) == '.exe') {
         if ($this->assemblyShouldBeInstrumented($file)) {
           $assemblies_to_instrument[] = $assembly_dir.DIRECTORY_SEPARATOR.$file;
         }
       }
     }
     if (count($assemblies_to_instrument) === 0) {
       return parent::buildTestFuture($test_assembly);
     }
     $future = new ExecFuture(
       '%C -o %s -c %s -a %s -w %s %Ls',
       trim($this->runtimeEngine.' '.$this->coverEngine),
       $cover_temp,
       $xunit_cmd,
       $xunit_args,
       $assembly_dir,
       $assemblies_to_instrument);
     $future->setCWD(Filesystem::resolvePath($this->projectRoot));
     return array(
       $future,
       $assembly_dir.DIRECTORY_SEPARATOR.$xunit_temp,
       $cover_temp);
   }
 
   /**
    * Returns coverage results for the unit tests.
    *
    * @param  string  The name of the coverage file if one was provided by
    *                 `buildTestFuture`.
    * @return array   Code coverage results, or null.
    */
   protected function parseCoverageResult($cover_file) {
     if ($this->getEnableCoverage() === false) {
       return parent::parseCoverageResult($cover_file);
     }
     return $this->readCoverage($cover_file);
   }
 
   /**
-   * Retrieves the cached results for a coverage result file.  The coverage
+   * Retrieves the cached results for a coverage result file. The coverage
    * result file is XML and can be large depending on what has been instrumented
    * so we cache it in case it's requested again.
    *
    * @param  string  The name of the coverage file.
    * @return array   Code coverage results, or null if not cached.
    */
   private function getCachedResultsIfPossible($cover_file) {
     if ($this->cachedResults == null) {
       $this->cachedResults = array();
     }
     if (array_key_exists((string)$cover_file, $this->cachedResults)) {
       return $this->cachedResults[(string)$cover_file];
     }
     return null;
   }
 
   /**
    * Stores the code coverage results in the cache.
    *
    * @param  string  The name of the coverage file.
    * @param  array   The results to cache.
    */
   private function addCachedResults($cover_file, array $results) {
     if ($this->cachedResults == null) {
       $this->cachedResults = array();
     }
     $this->cachedResults[(string)$cover_file] = $results;
   }
 
   /**
-   * Processes a set of XML tags as code coverage results.  We parse
+   * Processes a set of XML tags as code coverage results. We parse
    * the `instrumented` and `executed` tags with this method so that
    * we can access the data multiple times without a performance hit.
    *
    * @param  array  The array of XML tags to parse.
    * @return array  A PHP array containing the data.
    */
   private function processTags($tags) {
     $results = array();
     foreach ($tags as $tag) {
       $results[] = array(
         'file' => $tag->getAttribute('file'),
         'start' => $tag->getAttribute('start'),
         'end' => $tag->getAttribute('end'));
     }
     return $results;
   }
 
   /**
    * Reads the code coverage results from the cscover results file.
    *
    * @param  string  The path to the code coverage file.
    * @return array   The code coverage results.
    */
   public function readCoverage($cover_file) {
     $cached = $this->getCachedResultsIfPossible($cover_file);
     if ($cached !== null) {
       return $cached;
     }
 
     $coverage_dom = new DOMDocument();
     $coverage_dom->loadXML(Filesystem::readFile($cover_file));
 
     $modified = $this->getPaths();
     $files = array();
     $reports = array();
     $instrumented = array();
     $executed = array();
 
     $instrumented = $this->processTags(
       $coverage_dom->getElementsByTagName('instrumented'));
     $executed = $this->processTags(
       $coverage_dom->getElementsByTagName('executed'));
 
     foreach ($instrumented as $instrument) {
       $absolute_file = $instrument['file'];
       $relative_file = substr($absolute_file, strlen($this->projectRoot) + 1);
       if (!in_array($relative_file, $files)) {
         $files[] = $relative_file;
       }
     }
 
     foreach ($files as $file) {
       $absolute_file = Filesystem::resolvePath(
         $this->projectRoot.DIRECTORY_SEPARATOR.$file);
 
       // get total line count in file
       $line_count = count(file($absolute_file));
 
       $coverage = array();
       for ($i = 0; $i < $line_count; $i++) {
         $coverage[$i] = 'N';
       }
 
       foreach ($instrumented as $instrument) {
         if ($instrument['file'] !== $absolute_file) {
           continue;
         }
         for (
           $i = $instrument['start'];
           $i <= $instrument['end'];
           $i++) {
           $coverage[$i - 1] = 'U';
         }
       }
 
       foreach ($executed as $execute) {
         if ($execute['file'] !== $absolute_file) {
           continue;
         }
         for (
           $i = $execute['start'];
           $i <= $execute['end'];
           $i++) {
           $coverage[$i - 1] = 'C';
         }
       }
 
       $reports[$file] = implode($coverage);
     }
 
     $this->addCachedResults($cover_file, $reports);
     return $reports;
   }
+
 }
diff --git a/src/unit/engine/GoTestResultParser.php b/src/unit/engine/GoTestResultParser.php
index 827f4ab7..547dfc00 100644
--- a/src/unit/engine/GoTestResultParser.php
+++ b/src/unit/engine/GoTestResultParser.php
@@ -1,140 +1,134 @@
 <?php
 
 /**
  * Go Test Result Parsing utility
  *
- * Intended to enable custom unit engines derived
- * from Go's built-in test utility to reuse
- * common business logic related to parsing
- * Go test results.
- *
- * (To generate test output, run something like:
- * `go test -v`)
+ * (To generate test output, run something like: `go test -v`)
  */
 final class GoTestResultParser extends ArcanistBaseTestResultParser {
 
   /**
    * Parse test results from Go test report
    * (e.g. `go test -v`)
    *
    * @param string $path Path to test
    * @param string $test_results String containing Go test output
    *
    * @return array
    */
   public function parseTestResults($path, $test_results) {
-
     $test_results = explode("\n", $test_results);
 
     $results = array();
     // We'll get our full test case name at the end and add it back in
     $test_case_name = '';
 
     // Temp store for test case results (in case we run multiple test cases)
     $test_case_results = array();
     foreach ($test_results as $i => $line) {
 
       if (strncmp($line, '--- PASS', 8) === 0) {
         // We have a passing test
         $meta = array();
         preg_match(
           '/^--- PASS: (?P<test_name>.+) \((?P<time>.+) seconds\).*/',
           $line,
           $meta);
 
         $result = new ArcanistUnitTestResult();
         // For now set name without test case, we'll add it later
         $result->setName($meta['test_name']);
         $result->setResult(ArcanistUnitTestResult::RESULT_PASS);
         $result->setDuration($meta['time']);
 
         $test_case_results[] = $result;
 
         continue;
       }
 
       if (strncmp($line, '--- FAIL', 8) === 0) {
         // We have a failing test
         $reason = trim($test_results[$i + 1]);
         $meta = array();
         preg_match(
           '/^--- FAIL: (?P<test_name>.+) \((?P<time>.+) seconds\).*/',
           $line,
           $meta);
 
         $result = new ArcanistUnitTestResult();
         $result->setName($meta['test_name']);
         $result->setResult(ArcanistUnitTestResult::RESULT_FAIL);
         $result->setDuration($meta['time']);
         $result->setUserData($reason."\n");
 
         $test_case_results[] = $result;
 
         continue;
       }
 
       if (strncmp($line, 'ok', 2) === 0) {
         $meta = array();
         preg_match(
           '/^ok[\s\t]+(?P<test_name>\w.*)[\s\t]+(?P<time>.*)s.*/',
           $line,
           $meta);
 
         $test_case_name = str_replace('/', '::', $meta['test_name']);
 
         // Our test case passed
         // check to make sure we were in verbose (-v) mode
         if (empty($test_case_results)) {
           // We weren't in verbose mode
           // create one successful result for the whole test case
           $test_name = 'Go::TestCase::'.$test_case_name;
 
           $result = new ArcanistUnitTestResult();
           $result->setName($test_name);
           $result->setResult(ArcanistUnitTestResult::RESULT_PASS);
           $result->setDuration($meta['time']);
 
           $results[] = $result;
         } else {
           $test_case_results = $this->fixNames(
             $test_case_results,
             $test_case_name);
           $results = array_merge($results, $test_case_results);
           $test_case_results = array();
         }
 
         continue;
       }
 
       if (strncmp($line, "FAIL\t", 5) === 0) {
         $meta = array();
         preg_match(
           '/^FAIL[\s\t]+(?P<test_name>\w.*)[\s\t]+.*/',
           $line,
           $meta);
 
         $test_case_name = str_replace('/', '::', $meta['test_name']);
 
         $test_case_results = $this->fixNames(
           $test_case_results,
           $test_case_name);
         $results = array_merge($results, $test_case_results);
         $test_case_results = array();
 
         continue;
       }
     }
 
     return $results;
   }
 
   private function fixNames($test_case_results, $test_case_name) {
 
     foreach ($test_case_results as &$result) {
       $test_name = $result->getName();
       $result->setName('Go::Test::'.$test_case_name.'::'.$test_name);
     }
 
     return $test_case_results;
   }
+
 }
diff --git a/src/unit/engine/NoseTestEngine.php b/src/unit/engine/NoseTestEngine.php
index f59dcd09..6abf991f 100644
--- a/src/unit/engine/NoseTestEngine.php
+++ b/src/unit/engine/NoseTestEngine.php
@@ -1,167 +1,162 @@
 <?php
 
 /**
  * Very basic 'nose' unit test engine wrapper.
  *
  * Requires nose 1.1.3 for code coverage.
- *
- * @group unitrun
  */
 final class NoseTestEngine extends ArcanistBaseUnitTestEngine {
 
   public function run() {
-
     $paths = $this->getPaths();
 
     $affected_tests = array();
     foreach ($paths as $path) {
       $absolute_path = Filesystem::resolvePath($path);
 
       if (is_dir($absolute_path)) {
         $absolute_test_path = Filesystem::resolvePath('tests/'.$path);
         if (is_readable($absolute_test_path)) {
           $affected_tests[] = $absolute_test_path;
         }
       }
 
       if (is_readable($absolute_path)) {
         $filename = basename($path);
         $directory = dirname($path);
 
         // assumes directory layout: tests/<package>/test_<module>.py
         $relative_test_path = 'tests/'.$directory.'/test_'.$filename;
         $absolute_test_path = Filesystem::resolvePath($relative_test_path);
 
         if (is_readable($absolute_test_path)) {
           $affected_tests[] = $absolute_test_path;
         }
       }
     }
 
     return $this->runTests($affected_tests, './');
   }
 
   public function runTests($test_paths, $source_path) {
     if (empty($test_paths)) {
       return array();
     }
 
     $futures = array();
     $tmpfiles = array();
     foreach ($test_paths as $test_path) {
       $xunit_tmp = new TempFile();
       $cover_tmp = new TempFile();
 
-      $future = $this->buildTestFuture($test_path,
-                                       $xunit_tmp,
-                                       $cover_tmp);
+      $future = $this->buildTestFuture($test_path, $xunit_tmp, $cover_tmp);
 
       $futures[$test_path] = $future;
       $tmpfiles[$test_path] = array(
         'xunit' => $xunit_tmp,
         'cover' => $cover_tmp,
       );
     }
 
     $results = array();
     foreach (Futures($futures)->limit(4) as $test_path => $future) {
       try {
         list($stdout, $stderr) = $future->resolvex();
       } catch(CommandException $exc) {
         if ($exc->getError() > 1) {
           // 'nose' returns 1 when tests are failing/broken.
           throw $exc;
         }
       }
 
       $xunit_tmp = $tmpfiles[$test_path]['xunit'];
       $cover_tmp = $tmpfiles[$test_path]['cover'];
 
       $this->parser = new ArcanistXUnitTestResultParser();
       $results[] = $this->parseTestResults($source_path,
                                            $xunit_tmp,
                                            $cover_tmp);
     }
 
     return array_mergev($results);
   }
 
   public function buildTestFuture($path, $xunit_tmp, $cover_tmp) {
     $cmd_line = csprintf('nosetests --with-xunit --xunit-file=%s',
                          $xunit_tmp);
 
     if ($this->getEnableCoverage() !== false) {
-      $cmd_line .= csprintf(' --with-coverage --cover-xml '.
-                            '--cover-xml-file=%s',
-                            $cover_tmp);
+      $cmd_line .= csprintf(
+        ' --with-coverage --cover-xml --cover-xml-file=%s',
+        $cover_tmp);
     }
 
     return new ExecFuture('%C %s', $cmd_line, $path);
   }
 
   public function parseTestResults($source_path, $xunit_tmp, $cover_tmp) {
     $results = $this->parser->parseTestResults(
       Filesystem::readFile($xunit_tmp));
 
     // coverage is for all testcases in the executed $path
     if ($this->getEnableCoverage() !== false) {
       $coverage = $this->readCoverage($cover_tmp, $source_path);
       foreach ($results as $result) {
         $result->setCoverage($coverage);
       }
     }
 
     return $results;
   }
 
   public function readCoverage($cover_file, $source_path) {
     $coverage_dom = new DOMDocument();
     $coverage_dom->loadXML(Filesystem::readFile($cover_file));
 
     $reports = array();
     $classes = $coverage_dom->getElementsByTagName('class');
 
     foreach ($classes as $class) {
       $path = $class->getAttribute('filename');
       $root = $this->getWorkingCopy()->getProjectRoot();
 
       if (!Filesystem::isDescendant($path, $root)) {
         continue;
       }
 
       // get total line count in file
       $line_count = count(phutil_split_lines(Filesystem::readFile($path)));
 
       $coverage = '';
       $start_line = 1;
       $lines = $class->getElementsByTagName('line');
       for ($ii = 0; $ii < $lines->length; $ii++) {
         $line = $lines->item($ii);
 
         $next_line = intval($line->getAttribute('number'));
         for ($start_line; $start_line < $next_line; $start_line++) {
           $coverage .= 'N';
         }
 
         if (intval($line->getAttribute('hits')) == 0) {
           $coverage .= 'U';
         } else if (intval($line->getAttribute('hits')) > 0) {
           $coverage .= 'C';
         }
 
         $start_line++;
       }
 
       if ($start_line < $line_count) {
         foreach (range($start_line, $line_count) as $line_num) {
           $coverage .= 'N';
         }
       }
 
       $reports[$path] = $coverage;
     }
 
     return $reports;
   }
 
 }
diff --git a/src/unit/engine/PhpunitResultParser.php b/src/unit/engine/PhpunitResultParser.php
index 0868fae1..4a77f626 100644
--- a/src/unit/engine/PhpunitResultParser.php
+++ b/src/unit/engine/PhpunitResultParser.php
@@ -1,189 +1,183 @@
 <?php
 
 /**
  * PHPUnit Result Parsing utility
  *
- * Intended to enable custom unit engines derived
- * from phpunit to reuse common business logic related
- * to parsing phpunit test results and reports
- *
- * For an example on how to integrate with your test
- * engine, see PhpunitTestEngine.
- *
+ * For an example on how to integrate with your test engine, see
+ * @{class:PhpunitTestEngine}.
  */
 final class PhpunitResultParser extends ArcanistBaseTestResultParser {
 
   /**
    * Parse test results from phpunit json report
    *
    * @param string $path Path to test
    * @param string $test_results String containing phpunit json report
    *
    * @return array
    */
   public function parseTestResults($path, $test_results) {
-
     if (!$test_results) {
       $result = id(new ArcanistUnitTestResult())
         ->setName($path)
         ->setUserData($this->stderr)
         ->setResult(ArcanistUnitTestResult::RESULT_BROKEN);
       return array($result);
     }
 
     $report = $this->getJsonReport($test_results);
 
     // coverage is for all testcases in the executed $path
     $coverage = array();
     if ($this->enableCoverage !== false) {
       $coverage = $this->readCoverage();
     }
 
     $results = array();
     foreach ($report as $event) {
       switch ($event->event) {
       case 'test':
         break;
       case 'testStart':
         $lastTestFinished = false;
         // fall through
         default:
           continue 2; // switch + loop
       }
 
       $status = ArcanistUnitTestResult::RESULT_PASS;
       $user_data = '';
 
       if ('fail' == $event->status) {
         $status = ArcanistUnitTestResult::RESULT_FAIL;
         $user_data  .= $event->message."\n";
         foreach ($event->trace as $trace) {
           $user_data .= sprintf("\n%s:%s", $trace->file, $trace->line);
         }
       } else if ('error' == $event->status) {
         if (strpos($event->message, 'Skipped Test') !== false) {
           $status = ArcanistUnitTestResult::RESULT_SKIP;
           $user_data .= $event->message;
         } else if (strpos($event->message, 'Incomplete Test') !== false) {
           $status = ArcanistUnitTestResult::RESULT_SKIP;
           $user_data .= $event->message;
         } else {
           $status = ArcanistUnitTestResult::RESULT_BROKEN;
           $user_data  .= $event->message;
           foreach ($event->trace as $trace) {
             $user_data .= sprintf("\n%s:%s", $trace->file, $trace->line);
           }
         }
       }
 
       $name = preg_replace('/ \(.*\)/s', '', $event->test);
 
       $result = new ArcanistUnitTestResult();
       $result->setName($name);
       $result->setResult($status);
       $result->setDuration($event->time);
       $result->setCoverage($coverage);
       $result->setUserData($user_data);
 
       $results[] = $result;
       $lastTestFinished = true;
     }
 
     if (!$lastTestFinished) {
       $results[] = id(new ArcanistUnitTestResult())
         ->setName($event->test) // use last event
         ->setUserData($this->stderr)
         ->setResult(ArcanistUnitTestResult::RESULT_BROKEN);
     }
     return $results;
   }
 
   /**
    * Read the coverage from phpunit generated clover report
    *
    * @return array
    */
   private function readCoverage() {
     $test_results = Filesystem::readFile($this->coverageFile);
     if (empty($test_results)) {
       return array();
     }
 
     $coverage_dom = new DOMDocument();
     $coverage_dom->loadXML($test_results);
 
     $reports = array();
     $files = $coverage_dom->getElementsByTagName('file');
 
     foreach ($files as $file) {
       $class_path = $file->getAttribute('name');
       if (empty($this->affectedTests[$class_path])) {
         continue;
       }
       $test_path = $this->affectedTests[$file->getAttribute('name')];
       // get total line count in file
       $line_count = count(file($class_path));
 
       $coverage = '';
       $start_line = 1;
       $lines = $file->getElementsByTagName('line');
       for ($ii = 0; $ii < $lines->length; $ii++) {
         $line = $lines->item($ii);
         for (; $start_line < $line->getAttribute('num'); $start_line++) {
           $coverage .= 'N';
         }
 
         if ($line->getAttribute('type') != 'stmt') {
           $coverage .= 'N';
         } else {
           if ((int) $line->getAttribute('count') == 0) {
             $coverage .= 'U';
           } else if ((int) $line->getAttribute('count') > 0) {
             $coverage .= 'C';
           }
         }
 
         $start_line++;
       }
 
       for (; $start_line <= $line_count; $start_line++) {
         $coverage .= 'N';
       }
 
       $len = strlen($this->projectRoot.DIRECTORY_SEPARATOR);
       $class_path = substr($class_path, $len);
       $reports[$class_path] = $coverage;
     }
 
     return $reports;
   }
 
   /**
    * We need this non-sense to make json generated by phpunit
    * valid.
    *
    * @param string $json String containing JSON report
-   *
    * @return array JSON decoded array
    */
   private function getJsonReport($json) {
 
     if (empty($json)) {
       throw new Exception('JSON report file is empty, '.
         'it probably means that phpunit failed to run tests. '.
         'Try running arc unit with --trace option and then run '.
         'generated phpunit command yourself, you might get the '.
         'answer.'
       );
     }
 
     $json = preg_replace('/}{\s*"/', '},{"', $json);
     $json = '['.$json.']';
     $json = json_decode($json);
     if (!is_array($json)) {
       throw new Exception('JSON could not be decoded');
     }
 
     return $json;
   }
+
 }
diff --git a/src/unit/engine/PhpunitTestEngine.php b/src/unit/engine/PhpunitTestEngine.php
index d36f00b3..9395f4b8 100644
--- a/src/unit/engine/PhpunitTestEngine.php
+++ b/src/unit/engine/PhpunitTestEngine.php
@@ -1,287 +1,277 @@
 <?php
 
 /**
- * PHPUnit wrapper
- *
- * To use, set unit.engine in .arcconfig, or use --engine flag
- * with arc unit. Currently supports only class & test files
- * (no directory support).
- * To use custom phpunit configuration, set phpunit_config in
- * .arcconfig (e.g. app/phpunit.xml.dist).
- *
- * @group unitrun
+ * PHPUnit wrapper.
  */
 final class PhpunitTestEngine extends ArcanistBaseUnitTestEngine {
 
   private $configFile;
   private $phpunitBinary = 'phpunit';
   private $affectedTests;
   private $projectRoot;
 
   public function run() {
-
     $this->projectRoot = $this->getWorkingCopy()->getProjectRoot();
     $this->affectedTests = array();
     foreach ($this->getPaths() as $path) {
 
       $path = Filesystem::resolvePath($path, $this->projectRoot);
 
       // TODO: add support for directories
       // Users can call phpunit on the directory themselves
       if (is_dir($path)) {
         continue;
       }
 
       // Not sure if it would make sense to go further if
       // it is not a .php file
       if (substr($path, -4) != '.php') {
         continue;
       }
 
       if (substr($path, -8) == 'Test.php') {
         // Looks like a valid test file name.
         $this->affectedTests[$path] = $path;
         continue;
       }
 
       if ($test = $this->findTestFile($path)) {
         $this->affectedTests[$path] = $test;
       }
 
     }
 
     if (empty($this->affectedTests)) {
       throw new ArcanistNoEffectException('No tests to run.');
     }
 
     $this->prepareConfigFile();
     $futures = array();
     $tmpfiles = array();
     foreach ($this->affectedTests as $class_path => $test_path) {
       if (!Filesystem::pathExists($test_path)) {
         continue;
       }
       $json_tmp = new TempFile();
       $clover_tmp = null;
       $clover = null;
       if ($this->getEnableCoverage() !== false) {
         $clover_tmp = new TempFile();
         $clover = csprintf('--coverage-clover %s', $clover_tmp);
       }
 
       $config = $this->configFile ? csprintf('-c %s', $this->configFile) : null;
 
       $stderr = '-d display_errors=stderr';
 
       $futures[$test_path] = new ExecFuture('%C %C %C --log-json %s %C %s',
         $this->phpunitBinary, $config, $stderr, $json_tmp, $clover, $test_path);
       $tmpfiles[$test_path] = array(
         'json' => $json_tmp,
         'clover' => $clover_tmp,
       );
-
-
     }
 
     $results = array();
     foreach (Futures($futures)->limit(4) as $test => $future) {
 
       list($err, $stdout, $stderr) = $future->resolve();
 
       $results[] = $this->parseTestResults(
         $test,
         $tmpfiles[$test]['json'],
         $tmpfiles[$test]['clover'],
         $stderr);
     }
 
     return array_mergev($results);
   }
 
   /**
-   * Parse test results from phpunit json report
+   * Parse test results from phpunit json report.
    *
    * @param string $path Path to test
    * @param string $json_tmp Path to phpunit json report
    * @param string $clover_tmp Path to phpunit clover report
    * @param string $stderr Data written to stderr
    *
    * @return array
    */
   private function parseTestResults($path, $json_tmp, $clover_tmp, $stderr) {
     $test_results = Filesystem::readFile($json_tmp);
     return id(new PhpunitResultParser())
       ->setEnableCoverage($this->getEnableCoverage())
       ->setProjectRoot($this->projectRoot)
       ->setCoverageFile($clover_tmp)
       ->setAffectedTests($this->affectedTests)
       ->setStderr($stderr)
       ->parseTestResults($path, $test_results);
   }
 
 
   /**
    * Search for test cases for a given file in a large number of "reasonable"
    * locations. See @{method:getSearchLocationsForTests} for specifics.
    *
    * TODO: Add support for finding tests in testsuite folders from
    * phpunit.xml configuration.
    *
    * @param   string      PHP file to locate test cases for.
    * @return  string|null Path to test cases, or null.
    */
   private function findTestFile($path) {
     $root = $this->projectRoot;
     $path = Filesystem::resolvePath($path, $root);
 
     $file = basename($path);
     $possible_files = array(
       $file,
       substr($file, 0, -4).'Test.php',
     );
 
     $search = self::getSearchLocationsForTests($path);
 
     foreach ($search as $search_path) {
       foreach ($possible_files as $possible_file) {
         $full_path = $search_path.$possible_file;
         if (!Filesystem::pathExists($full_path)) {
           // If the file doesn't exist, it's clearly a miss.
           continue;
         }
         if (!Filesystem::isDescendant($full_path, $root)) {
           // Don't look above the project root.
           continue;
         }
         if (0 == strcasecmp(Filesystem::resolvePath($full_path), $path)) {
           // Don't return the original file.
           continue;
         }
         return $full_path;
       }
     }
 
     return null;
   }
 
 
   /**
    * Get places to look for PHP Unit tests that cover a given file. For some
    * file "/a/b/c/X.php", we look in the same directory:
    *
    *  /a/b/c/
    *
    * We then look in all parent directories for a directory named "tests/"
    * (or "Tests/"):
    *
    *  /a/b/c/tests/
    *  /a/b/tests/
    *  /a/tests/
    *  /tests/
    *
    * We also try to replace each directory component with "tests/":
    *
    *  /a/b/tests/
    *  /a/tests/c/
    *  /tests/b/c/
    *
    * We also try to add "tests/" at each directory level:
    *
    *  /a/b/c/tests/
    *  /a/b/tests/c/
    *  /a/tests/b/c/
    *  /tests/a/b/c/
    *
    * This finds tests with a layout like:
    *
    *  docs/
    *  src/
    *  tests/
    *
    * ...or similar. This list will be further pruned by the caller; it is
    * intentionally filesystem-agnostic to be unit testable.
    *
    * @param   string        PHP file to locate test cases for.
    * @return  list<string>  List of directories to search for tests in.
    */
   public static function getSearchLocationsForTests($path) {
     $file = basename($path);
     $dir  = dirname($path);
 
     $test_dir_names = array('tests', 'Tests');
 
     $try_directories = array();
 
     // Try in the current directory.
     $try_directories[] = array($dir);
 
     // Try in a tests/ directory anywhere in the ancestry.
     foreach (Filesystem::walkToRoot($dir) as $parent_dir) {
       if ($parent_dir == '/') {
         // We'll restore this later.
         $parent_dir = '';
       }
       foreach ($test_dir_names as $test_dir_name) {
         $try_directories[] = array($parent_dir, $test_dir_name);
       }
     }
 
     // Try replacing each directory component with 'tests/'.
     $parts = trim($dir, DIRECTORY_SEPARATOR);
     $parts = explode(DIRECTORY_SEPARATOR, $parts);
     foreach (array_reverse(array_keys($parts)) as $key) {
       foreach ($test_dir_names as $test_dir_name) {
         $try = $parts;
         $try[$key] = $test_dir_name;
         array_unshift($try, '');
         $try_directories[] = $try;
       }
     }
 
     // Try adding 'tests/' at each level.
     foreach (array_reverse(array_keys($parts)) as $key) {
       foreach ($test_dir_names as $test_dir_name) {
         $try = $parts;
         $try[$key] = $test_dir_name.DIRECTORY_SEPARATOR.$try[$key];
         array_unshift($try, '');
         $try_directories[] = $try;
       }
     }
 
     $results = array();
     foreach ($try_directories as $parts) {
       $results[implode(DIRECTORY_SEPARATOR, $parts).DIRECTORY_SEPARATOR] = true;
     }
 
     return array_keys($results);
   }
 
   /**
-   * Tries to find and update phpunit configuration file
-   * based on phpunit_config option in .arcconfig
+   * Tries to find and update phpunit configuration file based on
+   * `phpunit_config` option in `.arcconfig`.
    */
   private function prepareConfigFile() {
     $project_root = $this->projectRoot.DIRECTORY_SEPARATOR;
     $config = $this->getConfigurationManager()->getConfigFromAnySource(
       'phpunit_config');
 
     if ($config) {
       if (Filesystem::pathExists($project_root.$config)) {
         $this->configFile = $project_root.$config;
       } else {
         throw new Exception('PHPUnit configuration file was not '.
           'found in '.$project_root.$config);
       }
     }
     $bin = $this->getConfigurationManager()->getConfigFromAnySource(
       'unit.phpunit.binary');
     if ($bin) {
       if (Filesystem::binaryExists($bin)) {
         $this->phpunitBinary = $bin;
       }
       else {
         $this->phpunitBinary = Filesystem::resolvePath($bin, $project_root);
       }
     }
   }
+
 }
diff --git a/src/unit/engine/PhutilUnitTestEngine.php b/src/unit/engine/PhutilUnitTestEngine.php
index fe0a3d50..38ed99c3 100644
--- a/src/unit/engine/PhutilUnitTestEngine.php
+++ b/src/unit/engine/PhutilUnitTestEngine.php
@@ -1,193 +1,191 @@
 <?php
 
 /**
  * Very basic unit test engine which runs libphutil tests.
- *
- * @group unitrun
  */
 final class PhutilUnitTestEngine extends ArcanistBaseUnitTestEngine {
 
   protected function supportsRunAllTests() {
     return true;
   }
 
   public function run() {
     if ($this->getRunAllTests()) {
       $run_tests = $this->getAllTests();
     } else {
       $run_tests = $this->getTestsForPaths();
     }
 
     if (!$run_tests) {
       throw new ArcanistNoEffectException('No tests to run.');
     }
 
     $enable_coverage = $this->getEnableCoverage();
     if ($enable_coverage !== false) {
       if (!function_exists('xdebug_start_code_coverage')) {
         if ($enable_coverage === true) {
           throw new ArcanistUsageException(
             'You specified --coverage but xdebug is not available, so '.
             'coverage can not be enabled for PhutilUnitTestEngine.');
         }
       } else {
         $enable_coverage = true;
       }
     }
 
     $project_root = $this->getWorkingCopy()->getProjectRoot();
 
     $test_cases = array();
     foreach ($run_tests as $test_class) {
       $test_case = newv($test_class, array());
       $test_case->setEnableCoverage($enable_coverage);
       $test_case->setProjectRoot($project_root);
       if ($this->getPaths()) {
         $test_case->setPaths($this->getPaths());
       }
       if ($this->renderer) {
         $test_case->setRenderer($this->renderer);
       }
       $test_cases[] = $test_case;
     }
 
     foreach ($test_cases as $test_case) {
       $test_case->willRunTestCases($test_cases);
     }
 
     $results = array();
     foreach ($test_cases as $test_case) {
       $results[] = $test_case->run();
     }
     $results = array_mergev($results);
 
     foreach ($test_cases as $test_case) {
       $test_case->didRunTestCases($test_cases);
     }
 
     return $results;
   }
 
   private function getAllTests() {
     $project_root = $this->getWorkingCopy()->getProjectRoot();
 
     $symbols = id(new PhutilSymbolLoader())
       ->setType('class')
       ->setAncestorClass('ArcanistPhutilTestCase')
       ->setConcreteOnly(true)
       ->selectSymbolsWithoutLoading();
 
     $in_working_copy = array();
 
     $run_tests = array();
     foreach ($symbols as $symbol) {
       if (!preg_match('@(?:^|/)__tests__/@', $symbol['where'])) {
         continue;
       }
 
       $library = $symbol['library'];
 
       if (!isset($in_working_copy[$library])) {
         $library_root = phutil_get_library_root($library);
         $in_working_copy[$library] = Filesystem::isDescendant(
           $library_root,
           $project_root);
       }
 
       if ($in_working_copy[$library]) {
         $run_tests[] = $symbol['name'];
       }
     }
 
     return $run_tests;
   }
 
   private function getTestsForPaths() {
     $project_root = $this->getWorkingCopy()->getProjectRoot();
 
     $look_here = array();
 
     foreach ($this->getPaths() as $path) {
       $library_root = phutil_get_library_root_for_path($path);
       if (!$library_root) {
         continue;
       }
       $library_name = phutil_get_library_name_for_root($library_root);
 
       if (!$library_name) {
         throw new Exception(
           "Attempting to run unit tests on a libphutil library which has not ".
           "been loaded, at:\n\n".
           "    {$library_root}\n\n".
           "This probably means one of two things:\n\n".
           "    - You may need to add this library to .arcconfig.\n".
           "    - You may be running tests on a copy of libphutil or arcanist\n".
           "      using a different copy of libphutil or arcanist. This\n".
           "      operation is not supported.");
       }
 
       $path = Filesystem::resolvePath($path, $project_root);
 
       if (!is_dir($path)) {
         $path = dirname($path);
       }
 
       if ($path == $library_root) {
         $look_here[$library_name.':.'] = array(
           'library' => $library_name,
           'path'    => '',
         );
       } else if (!Filesystem::isDescendant($path, $library_root)) {
         // We have encountered some kind of symlink maze -- for instance, $path
         // is some symlink living outside the library that links into some file
         // inside the library. Just ignore these cases, since the affected file
         // does not actually lie within the library.
         continue;
       } else {
         $library_path = Filesystem::readablePath($path, $library_root);
         do {
           $look_here[$library_name.':'.$library_path] = array(
             'library' => $library_name,
             'path'    => $library_path,
           );
           $library_path = dirname($library_path);
         } while ($library_path != '.');
       }
     }
 
     // Look for any class that extends ArcanistPhutilTestCase inside a
     // __tests__ directory in any parent directory of every affected file.
     //
     // The idea is that "infrastructure/__tests__/" tests defines general tests
     // for all of "infrastructure/", and those tests run for any change in
     // "infrastructure/". However, "infrastructure/concrete/rebar/__tests__/"
     // defines more specific tests that run only when rebar/ (or some
     // subdirectory) changes.
 
     $run_tests = array();
     foreach ($look_here as $path_info) {
       $library = $path_info['library'];
       $path    = $path_info['path'];
 
       $symbols = id(new PhutilSymbolLoader())
         ->setType('class')
         ->setLibrary($library)
         ->setPathPrefix(($path ? $path.'/' : '').'__tests__/')
         ->setAncestorClass('ArcanistPhutilTestCase')
         ->setConcreteOnly(true)
         ->selectAndLoadSymbols();
 
       foreach ($symbols as $symbol) {
         $run_tests[$symbol['name']] = true;
       }
     }
     $run_tests = array_keys($run_tests);
 
     return $run_tests;
   }
 
   public function shouldEchoTestResults() {
     return !$this->renderer;
   }
 
 }
diff --git a/src/unit/engine/PytestTestEngine.php b/src/unit/engine/PytestTestEngine.php
index d4deb79d..5a3aedce 100644
--- a/src/unit/engine/PytestTestEngine.php
+++ b/src/unit/engine/PytestTestEngine.php
@@ -1,135 +1,135 @@
 <?php
 
 /**
  * Very basic 'py.test' unit test engine wrapper.
- *
- * @group unitrun
  */
 final class PytestTestEngine extends ArcanistBaseUnitTestEngine {
 
   public function run() {
     $working_copy = $this->getWorkingCopy();
     $this->project_root = $working_copy->getProjectRoot();
 
     $junit_tmp = new TempFile();
     $cover_tmp = new TempFile();
 
     $future = $this->buildTestFuture($junit_tmp, $cover_tmp);
     $future->resolvex();
 
     $future = new ExecFuture('coverage xml -o %s', $cover_tmp);
     $future->setCWD($this->project_root);
     $future->resolvex();
 
     return $this->parseTestResults($junit_tmp, $cover_tmp);
   }
 
   public function buildTestFuture($junit_tmp, $cover_tmp) {
     $paths = $this->getPaths();
 
-    $cmd_line = csprintf('py.test --junitxml %s',
-                         $junit_tmp);
+    $cmd_line = csprintf('py.test --junitxml %s', $junit_tmp);
 
-  if ($this->getEnableCoverage() !== false) {
-      $cmd_line = csprintf('coverage run --source %s -m %C',
-                           $this->project_root, $cmd_line);
+    if ($this->getEnableCoverage() !== false) {
+      $cmd_line = csprintf(
+        'coverage run --source %s -m %C',
+        $this->project_root,
+        $cmd_line);
     }
 
     return new ExecFuture('%C', $cmd_line);
   }
 
   public function parseTestResults($junit_tmp, $cover_tmp) {
     $parser = new ArcanistXUnitTestResultParser();
     $results = $parser->parseTestResults(
       Filesystem::readFile($junit_tmp));
 
     if ($this->getEnableCoverage() !== false) {
       $coverage_report = $this->readCoverage($cover_tmp);
       foreach ($results as $result) {
           $result->setCoverage($coverage_report);
       }
     }
 
     return $results;
   }
 
   public function readCoverage($path) {
     $coverage_data = Filesystem::readFile($path);
     if (empty($coverage_data)) {
        return array();
     }
 
     $coverage_dom = new DOMDocument();
     $coverage_dom->loadXML($coverage_data);
 
     $paths = $this->getPaths();
     $reports = array();
     $classes = $coverage_dom->getElementsByTagName('class');
 
     foreach ($classes as $class) {
       // filename is actually python module path with ".py" at the end,
       // e.g.: tornado.web.py
       $relative_path = explode('.', $class->getAttribute('filename'));
       array_pop($relative_path);
       $relative_path = implode('/', $relative_path);
 
       // first we check if the path is a directory (a Python package), if it is
       // set relative and absolute paths to have __init__.py at the end.
       $absolute_path = Filesystem::resolvePath($relative_path);
       if (is_dir($absolute_path)) {
         $relative_path .= '/__init__.py';
         $absolute_path .= '/__init__.py';
       }
 
       // then we check if the path with ".py" at the end is file (a Python
       // submodule), if it is - set relative and absolute paths to have
       // ".py" at the end.
       if (is_file($absolute_path.'.py')) {
         $relative_path .= '.py';
         $absolute_path .= '.py';
       }
 
       if (!file_exists($absolute_path)) {
         continue;
       }
 
       if (!in_array($relative_path, $paths)) {
         continue;
       }
 
       // get total line count in file
       $line_count = count(file($absolute_path));
 
       $coverage = '';
       $start_line = 1;
       $lines = $class->getElementsByTagName('line');
       for ($ii = 0; $ii < $lines->length; $ii++) {
         $line = $lines->item($ii);
 
         $next_line = intval($line->getAttribute('number'));
         for ($start_line; $start_line < $next_line; $start_line++) {
             $coverage .= 'N';
         }
 
         if (intval($line->getAttribute('hits')) == 0) {
             $coverage .= 'U';
         }
         else if (intval($line->getAttribute('hits')) > 0) {
             $coverage .= 'C';
         }
 
         $start_line++;
       }
 
       if ($start_line < $line_count) {
         foreach (range($start_line, $line_count) as $line_num) {
           $coverage .= 'N';
         }
       }
 
       $reports[$relative_path] = $coverage;
     }
 
     return $reports;
   }
+
 }
diff --git a/src/unit/engine/XUnitTestEngine.php b/src/unit/engine/XUnitTestEngine.php
index f98f36b3..2fbfdd03 100644
--- a/src/unit/engine/XUnitTestEngine.php
+++ b/src/unit/engine/XUnitTestEngine.php
@@ -1,456 +1,452 @@
 <?php
 
 /**
  * Uses xUnit (http://xunit.codeplex.com/) to test C# code.
  *
  * Assumes that when modifying a file with a path like `SomeAssembly/MyFile.cs`,
  * that the test assembly that verifies the functionality of `SomeAssembly` is
  * located at `SomeAssembly.Tests`.
  *
- * @group unitrun
  * @concrete-extensible
  */
 class XUnitTestEngine extends ArcanistBaseUnitTestEngine {
 
   protected $runtimeEngine;
   protected $buildEngine;
   protected $testEngine;
   protected $projectRoot;
   protected $xunitHintPath;
   protected $discoveryRules;
 
   /**
    * This test engine supports running all tests.
    */
   protected function supportsRunAllTests() {
     return true;
   }
 
   /**
-   * Determines what executables and test paths to use.  Between platforms
-   * this also changes whether the test engine is run under .NET or Mono.  It
-   * also ensures that all of the required binaries are available for the tests
-   * to run successfully.
+   * Determines what executables and test paths to use. Between platforms this
+   * also changes whether the test engine is run under .NET or Mono. It also
+   * ensures that all of the required binaries are available for the tests to
+   * run successfully.
    *
    * @return void
    */
   protected function loadEnvironment() {
     $this->projectRoot = $this->getWorkingCopy()->getProjectRoot();
 
     // Determine build engine.
     if (Filesystem::binaryExists('msbuild')) {
       $this->buildEngine = 'msbuild';
     } else if (Filesystem::binaryExists('xbuild')) {
       $this->buildEngine = 'xbuild';
     } else {
       throw new Exception('Unable to find msbuild or xbuild in PATH!');
     }
 
     // Determine runtime engine (.NET or Mono).
     if (phutil_is_windows()) {
       $this->runtimeEngine = '';
     } else if (Filesystem::binaryExists('mono')) {
       $this->runtimeEngine = Filesystem::resolveBinary('mono');
     } else {
       throw new Exception('Unable to find Mono and you are not on Windows!');
     }
 
     // Read the discovery rules.
     $this->discoveryRules =
       $this->getConfigurationManager()->getConfigFromAnySource(
         'unit.csharp.discovery');
     if ($this->discoveryRules === null) {
       throw new Exception(
         'You must configure discovery rules to map C# files '.
         'back to test projects (`unit.csharp.discovery` in .arcconfig).');
     }
 
     // Determine xUnit test runner path.
     if ($this->xunitHintPath === null) {
       $this->xunitHintPath =
         $this->getConfigurationManager()->getConfigFromAnySource(
           'unit.csharp.xunit.binary');
     }
     $xunit = $this->projectRoot.DIRECTORY_SEPARATOR.$this->xunitHintPath;
     if (file_exists($xunit) && $this->xunitHintPath !== null) {
       $this->testEngine = Filesystem::resolvePath($xunit);
     } else if (Filesystem::binaryExists('xunit.console.clr4.exe')) {
       $this->testEngine = 'xunit.console.clr4.exe';
     } else {
       throw new Exception(
-        "Unable to locate xUnit console runner.  Configure ".
+        "Unable to locate xUnit console runner. Configure ".
         "it with the `unit.csharp.xunit.binary' option in .arcconfig");
     }
   }
 
   /**
-   * Main entry point for the test engine.  Determines what assemblies to
-   * build and test based on the files that have changed.
+   * Main entry point for the test engine. Determines what assemblies to build
+   * and test based on the files that have changed.
    *
    * @return array   Array of test results.
    */
   public function run() {
 
     $this->loadEnvironment();
 
     if ($this->getRunAllTests()) {
       $paths = id(new FileFinder($this->projectRoot))->find();
     } else {
       $paths = $this->getPaths();
     }
 
     return $this->runAllTests($this->mapPathsToResults($paths));
   }
 
   /**
    * Applies the discovery rules to the set of paths specified.
    *
    * @param  array   Array of paths.
    * @return array   Array of paths to test projects and assemblies.
    */
   public function mapPathsToResults(array $paths) {
     $results = array();
     foreach ($this->discoveryRules as $regex => $targets) {
       $regex = str_replace('/', '\\/', $regex);
       foreach ($paths as $path) {
         if (preg_match('/'.$regex.'/', $path) === 1) {
           foreach ($targets as $target) {
             // Index 0 is the test project (.csproj file)
             // Index 1 is the output assembly (.dll file)
             $project = preg_replace('/'.$regex.'/', $target[0], $path);
             $project = $this->projectRoot.DIRECTORY_SEPARATOR.$project;
             $assembly = preg_replace('/'.$regex.'/', $target[1], $path);
             $assembly = $this->projectRoot.DIRECTORY_SEPARATOR.$assembly;
             if (file_exists($project)) {
               $project = Filesystem::resolvePath($project);
               $assembly = Filesystem::resolvePath($assembly);
 
               // Check to ensure uniqueness.
               $exists = false;
               foreach ($results as $existing) {
                 if ($existing['assembly'] === $assembly) {
                   $exists = true;
                   break;
                 }
               }
 
               if (!$exists) {
                 $results[] = array(
                   'project' => $project,
-                  'assembly' => $assembly);
+                  'assembly' => $assembly,
+                );
               }
             }
           }
         }
       }
     }
     return $results;
   }
 
   /**
    * Builds and runs the specified test assemblies.
    *
    * @param  array   Array of paths to test project files.
    * @return array   Array of test results.
    */
   public function runAllTests(array $test_projects) {
     if (empty($test_projects)) {
       return array();
     }
 
     $results = array();
     $results[] = $this->generateProjects();
     if ($this->resultsContainFailures($results)) {
       return array_mergev($results);
     }
     $results[] = $this->buildProjects($test_projects);
     if ($this->resultsContainFailures($results)) {
       return array_mergev($results);
     }
     $results[] = $this->testAssemblies($test_projects);
 
     return array_mergev($results);
   }
 
   /**
    * Determine whether or not a current set of results contains any failures.
    * This is needed since we build the assemblies as part of the unit tests, but
    * we can't run any of the unit tests if the build fails.
    *
    * @param  array   Array of results to check.
    * @return bool    If there are any failures in the results.
    */
   private function resultsContainFailures(array $results) {
     $results = array_mergev($results);
     foreach ($results as $result) {
       if ($result->getResult() != ArcanistUnitTestResult::RESULT_PASS) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * If the `Build` directory exists, we assume that this is a multi-platform
-   * project that requires generation of C# project files.  Because we want to
+   * project that requires generation of C# project files. Because we want to
    * test that the generation and subsequent build is whole, we need to
    * regenerate any projects in case the developer has added files through an
    * IDE and then forgotten to add them to the respective `.definitions` file.
    * By regenerating the projects we ensure that any missing definition entries
    * will cause the build to fail.
    *
    * @return array   Array of test results.
    */
   private function generateProjects() {
-
     // No "Build" directory; so skip generation of projects.
     if (!is_dir(Filesystem::resolvePath($this->projectRoot.'/Build'))) {
       return array();
     }
 
     // No "Protobuild.exe" file; so skip generation of projects.
     if (!is_file(Filesystem::resolvePath(
       $this->projectRoot.'/Protobuild.exe'))) {
 
       return array();
     }
 
     // Work out what platform the user is building for already.
     $platform = phutil_is_windows() ? 'Windows' : 'Linux';
     $files = Filesystem::listDirectory($this->projectRoot);
     foreach ($files as $file) {
       if (strtolower(substr($file, -4)) == '.sln') {
         $parts = explode('.', $file);
         $platform = $parts[count($parts) - 2];
         break;
       }
     }
 
     $regenerate_start = microtime(true);
     $regenerate_future = new ExecFuture(
       '%C Protobuild.exe --resync %s',
       $this->runtimeEngine,
       $platform);
     $regenerate_future->setCWD(Filesystem::resolvePath(
       $this->projectRoot));
     $results = array();
     $result = new ArcanistUnitTestResult();
     $result->setName("(regenerate projects for $platform)");
 
     try {
       $regenerate_future->resolvex();
       $result->setResult(ArcanistUnitTestResult::RESULT_PASS);
     } catch(CommandException $exc) {
       if ($exc->getError() > 1) {
         throw $exc;
       }
       $result->setResult(ArcanistUnitTestResult::RESULT_FAIL);
       $result->setUserdata($exc->getStdout());
     }
 
     $result->setDuration(microtime(true) - $regenerate_start);
     $results[] = $result;
     return $results;
   }
 
   /**
    * Build the projects relevant for the specified test assemblies and return
-   * the results of the builds as test results.  This build also passes the
+   * the results of the builds as test results. This build also passes the
    * "SkipTestsOnBuild" parameter when building the projects, so that MSBuild
    * conditionals can be used to prevent any tests running as part of the
    * build itself (since the unit tester is about to run each of the tests
    * individually).
    *
    * @param  array   Array of test assemblies.
    * @return array   Array of test results.
    */
   private function buildProjects(array $test_assemblies) {
     $build_futures = array();
     $build_failed = false;
     $build_start = microtime(true);
     $results = array();
     foreach ($test_assemblies as $test_assembly) {
       $build_future = new ExecFuture(
         '%C %s',
         $this->buildEngine,
         '/p:SkipTestsOnBuild=True');
       $build_future->setCWD(Filesystem::resolvePath(
         dirname($test_assembly['project'])));
       $build_futures[$test_assembly['project']] = $build_future;
     }
     $iterator = Futures($build_futures)->limit(1);
     foreach ($iterator as $test_assembly => $future) {
       $result = new ArcanistUnitTestResult();
       $result->setName('(build) '.$test_assembly);
 
       try {
         $future->resolvex();
         $result->setResult(ArcanistUnitTestResult::RESULT_PASS);
       } catch(CommandException $exc) {
         if ($exc->getError() > 1) {
           throw $exc;
         }
         $result->setResult(ArcanistUnitTestResult::RESULT_FAIL);
         $result->setUserdata($exc->getStdout());
         $build_failed = true;
       }
 
       $result->setDuration(microtime(true) - $build_start);
       $results[] = $result;
     }
     return $results;
   }
 
   /**
-   * Build the future for running a unit test.  This can be
-   * overridden to enable support for code coverage via
-   * another tool
+   * Build the future for running a unit test. This can be overridden to enable
+   * support for code coverage via another tool.
    *
    * @param  string  Name of the test assembly.
    * @return array   The future, output filename and coverage filename
    *                 stored in an array.
    */
   protected function buildTestFuture($test_assembly) {
       // FIXME: Can't use TempFile here as xUnit doesn't like
-      // UNIX-style full paths.  It sees the leading / as the
+      // UNIX-style full paths. It sees the leading / as the
       // start of an option flag, even when quoted.
       $xunit_temp = Filesystem::readRandomCharacters(10).'.results.xml';
       if (file_exists($xunit_temp)) {
         unlink($xunit_temp);
       }
       $future = new ExecFuture(
         '%C %s /xml %s',
         trim($this->runtimeEngine.' '.$this->testEngine),
         $test_assembly,
         $xunit_temp);
       $folder = Filesystem::resolvePath($this->projectRoot);
       $future->setCWD($folder);
       $combined = $folder.'/'.$xunit_temp;
       if (phutil_is_windows()) {
         $combined = $folder.'\\'.$xunit_temp;
       }
       return array($future, $combined, null);
   }
 
   /**
    * Run the xUnit test runner on each of the assemblies and parse the
    * resulting XML.
    *
    * @param  array   Array of test assemblies.
    * @return array   Array of test results.
    */
   private function testAssemblies(array $test_assemblies) {
-
     $results = array();
 
     // Build the futures for running the tests.
     $futures = array();
     $outputs = array();
     $coverages = array();
     foreach ($test_assemblies as $test_assembly) {
       list($future_r, $xunit_temp, $coverage) =
         $this->buildTestFuture($test_assembly['assembly']);
       $futures[$test_assembly['assembly']] = $future_r;
       $outputs[$test_assembly['assembly']] = $xunit_temp;
       $coverages[$test_assembly['assembly']] = $coverage;
     }
 
     // Run all of the tests.
     foreach (Futures($futures)->limit(8) as $test_assembly => $future) {
       list($err, $stdout, $stderr) = $future->resolve();
 
       if (file_exists($outputs[$test_assembly])) {
         $result = $this->parseTestResult(
           $outputs[$test_assembly],
           $coverages[$test_assembly]);
         $results[] = $result;
         unlink($outputs[$test_assembly]);
       } else {
         // FIXME: There's a bug in Mono which causes a segmentation fault
         // when xUnit.NET runs; this causes the XML file to not appear
-        // (depending on when the segmentation fault occurs).  See
+        // (depending on when the segmentation fault occurs). See
         // https://bugzilla.xamarin.com/show_bug.cgi?id=16379
         // for more information.
 
         // Since it's not possible for the user to correct this error, we
         // ignore the fact the tests didn't run here.
-        //
       }
     }
 
     return array_mergev($results);
   }
 
   /**
    * Returns null for this implementation as xUnit does not support code
-   * coverage directly.  Override this method in another class to provide
-   * code coverage information (also see `CSharpToolsUnitEngine`).
+   * coverage directly. Override this method in another class to provide code
+   * coverage information (also see @{class:CSharpToolsUnitEngine}).
    *
    * @param  string  The name of the coverage file if one was provided by
    *                 `buildTestFuture`.
    * @return array   Code coverage results, or null.
    */
   protected function parseCoverageResult($coverage) {
     return null;
   }
 
   /**
    * Parses the test results from xUnit.
    *
    * @param  string  The name of the xUnit results file.
    * @param  string  The name of the coverage file if one was provided by
-   *                 `buildTestFuture`.  This is passed through to
+   *                 `buildTestFuture`. This is passed through to
    *                 `parseCoverageResult`.
    * @return array   Test results.
    */
   private function parseTestResult($xunit_tmp, $coverage) {
     $xunit_dom = new DOMDocument();
     $xunit_dom->loadXML(Filesystem::readFile($xunit_tmp));
 
     $results = array();
     $tests = $xunit_dom->getElementsByTagName('test');
     foreach ($tests as $test) {
       $name = $test->getAttribute('name');
       $time = $test->getAttribute('time');
       $status = ArcanistUnitTestResult::RESULT_UNSOUND;
       switch ($test->getAttribute('result')) {
         case 'Pass':
           $status = ArcanistUnitTestResult::RESULT_PASS;
           break;
         case 'Fail':
           $status = ArcanistUnitTestResult::RESULT_FAIL;
           break;
         case 'Skip':
           $status = ArcanistUnitTestResult::RESULT_SKIP;
           break;
       }
       $userdata = '';
       $reason = $test->getElementsByTagName('reason');
       $failure = $test->getElementsByTagName('failure');
       if ($reason->length > 0 || $failure->length > 0) {
         $node = ($reason->length > 0) ? $reason : $failure;
         $message = $node->item(0)->getElementsByTagName('message');
         if ($message->length > 0) {
           $userdata = $message->item(0)->nodeValue;
         }
         $stacktrace = $node->item(0)->getElementsByTagName('stack-trace');
         if ($stacktrace->length > 0) {
           $userdata .= "\n".$stacktrace->item(0)->nodeValue;
         }
       }
 
       $result = new ArcanistUnitTestResult();
       $result->setName($name);
       $result->setResult($status);
       $result->setDuration($time);
       $result->setUserData($userdata);
       if ($coverage != null) {
         $result->setCoverage($this->parseCoverageResult($coverage));
       }
       $results[] = $result;
     }
 
     return $results;
   }
 
 }
diff --git a/src/unit/engine/__tests__/GoTestResultParserTestCase.php b/src/unit/engine/__tests__/GoTestResultParserTestCase.php
index a352bd6a..ace64a68 100644
--- a/src/unit/engine/__tests__/GoTestResultParserTestCase.php
+++ b/src/unit/engine/__tests__/GoTestResultParserTestCase.php
@@ -1,110 +1,106 @@
 <?php
 
 /**
  * Test for @{class:GoTestResultParser}.
- *
- * (putting tests in your tests so you can test
- * while you test)
- *
- * @group testcase
  */
 final class GoTestResultParserTestCase extends ArcanistTestCase {
 
   public function testSingleTestCaseSuccessful() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/go.single-test-case-successful');
 
     $parsed_results = id(new GoTestResultParser())
       ->parseTestResults('subpackage_test.go', $stubbed_results);
 
     $this->assertEqual(2, count($parsed_results));
     $this->assertEqual(
       'Go::Test::package::subpackage::TestFoo',
       $parsed_results[0]->getName());
     foreach ($parsed_results as $result) {
       $this->assertEqual(
         ArcanistUnitTestResult::RESULT_PASS,
         $result->getResult());
     }
   }
 
   public function testSingleTestCaseFailure() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/go.single-test-case-failure');
 
     $parsed_results = id(new GoTestResultParser())
       ->parseTestResults('subpackage_test.go', $stubbed_results);
 
     $this->assertEqual(2, count($parsed_results));
     $this->assertEqual(
       ArcanistUnitTestResult::RESULT_FAIL,
       $parsed_results[0]->getResult());
     $this->assertEqual(
       ArcanistUnitTestResult::RESULT_PASS,
       $parsed_results[1]->getResult());
   }
 
   public function testMultipleTestCasesSuccessful() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/go.multiple-test-cases-successful');
 
     $parsed_results = id(new GoTestResultParser())
       ->parseTestResults('package', $stubbed_results);
 
     $this->assertEqual(3, count($parsed_results));
     $this->assertEqual(
       'Go::Test::package::subpackage1::TestFoo1',
       $parsed_results[0]->getName());
     $this->assertEqual(
       'Go::Test::package::subpackage2::TestFoo2',
       $parsed_results[2]->getName());
     foreach ($parsed_results as $result) {
       $this->assertEqual(
         ArcanistUnitTestResult::RESULT_PASS,
         $result->getResult());
     }
   }
 
   public function testMultipleTestCasesFailure() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/go.multiple-test-cases-failure');
 
     $parsed_results = id(new GoTestResultParser())
       ->parseTestResults('package', $stubbed_results);
 
     $this->assertEqual(3, count($parsed_results));
     $this->assertEqual(
       'Go::Test::package::subpackage1::TestFoo1',
       $parsed_results[0]->getName());
     $this->assertEqual(
       'Go::Test::package::subpackage2::TestFoo2',
       $parsed_results[2]->getName());
     $this->assertEqual(
       ArcanistUnitTestResult::RESULT_PASS,
       $parsed_results[0]->getResult());
     $this->assertEqual(
       ArcanistUnitTestResult::RESULT_FAIL,
       $parsed_results[2]->getResult());
   }
 
   public function testNonVerboseOutput() {
     $stubbed_results = Filesystem::readFile(
       dirname(__FILE__).'/testresults/go.nonverbose');
 
     $parsed_results = id(new GoTestResultParser())
       ->parseTestResults('package', $stubbed_results);
 
     $this->assertEqual(2, count($parsed_results));
     $this->assertEqual(
       'Go::TestCase::package::subpackage1',
       $parsed_results[0]->getName());
     $this->assertEqual(
       'Go::TestCase::package::subpackage2',
       $parsed_results[1]->getName());
     foreach ($parsed_results as $result) {
       $this->assertEqual(
         ArcanistUnitTestResult::RESULT_PASS,
         $result->getResult());
     }
   }
+
 }
diff --git a/src/unit/engine/__tests__/PHPUnitTestEngineTestCase.php b/src/unit/engine/__tests__/PHPUnitTestEngineTestCase.php
index 2136a5f6..5c2b4ac4 100644
--- a/src/unit/engine/__tests__/PHPUnitTestEngineTestCase.php
+++ b/src/unit/engine/__tests__/PHPUnitTestEngineTestCase.php
@@ -1,45 +1,42 @@
 <?php
 
 /**
  * Tests for @{class:PHPUnitTestEngine}.
- *
- * @group testcase
  */
 final class PHPUnitTestEngineTestCase extends ArcanistTestCase {
 
   public function testSearchLocations() {
-
     $path = '/path/to/some/file/X.php';
 
     $this->assertEqual(
       array(
         '/path/to/some/file/',
         '/path/to/some/file/tests/',
         '/path/to/some/file/Tests/',
         '/path/to/some/tests/',
         '/path/to/some/Tests/',
         '/path/to/tests/',
         '/path/to/Tests/',
         '/path/tests/',
         '/path/Tests/',
         '/tests/',
         '/Tests/',
         '/path/to/tests/file/',
         '/path/to/Tests/file/',
         '/path/tests/some/file/',
         '/path/Tests/some/file/',
         '/tests/to/some/file/',
         '/Tests/to/some/file/',
         '/path/to/some/tests/file/',
         '/path/to/some/Tests/file/',
         '/path/to/tests/some/file/',
         '/path/to/Tests/some/file/',
         '/path/tests/to/some/file/',
         '/path/Tests/to/some/file/',
         '/tests/path/to/some/file/',
         '/Tests/path/to/some/file/',
       ),
       PhpunitTestEngine::getSearchLocationsForTests($path));
   }
 
 }
diff --git a/src/unit/engine/__tests__/PhutilUnitTestEngineTestCase.php b/src/unit/engine/__tests__/PhutilUnitTestEngineTestCase.php
index ec35b064..717c00b3 100644
--- a/src/unit/engine/__tests__/PhutilUnitTestEngineTestCase.php
+++ b/src/unit/engine/__tests__/PhutilUnitTestEngineTestCase.php
@@ -1,114 +1,112 @@
 <?php
 
 /**
  * Very meta test for @{class:PhutilUnitTestEngine}.
- *
- * @group testcase
  */
 final class PhutilUnitTestEngineTestCase extends ArcanistTestCase {
 
   static $allTestsCounter = 0;
   static $oneTestCounter = 0;
   static $distinctWillRunTests = array();
   static $distinctDidRunTests = array();
 
   protected function willRunTests() {
     self::$allTestsCounter++;
   }
 
   protected function didRunTests() {
     $this->assertEqual(
       1,
       self::$allTestsCounter,
       'Expect willRunTests() has been called once.');
 
     self::$allTestsCounter--;
 
     $actual_test_count = 4;
 
     $this->assertEqual(
       $actual_test_count,
       count(self::$distinctWillRunTests),
       'Expect willRunOneTest() was called once for each test.');
     $this->assertEqual(
       $actual_test_count,
       count(self::$distinctDidRunTests),
       'Expect didRunOneTest() was called once for each test.');
     $this->assertEqual(
       self::$distinctWillRunTests,
       self::$distinctDidRunTests,
       'Expect same tests had pre- and post-run callbacks invoked.');
   }
 
   public function __destruct() {
     if (self::$allTestsCounter !== 0) {
       throw new Exception(
         'didRunTests() was not called correctly after tests completed!');
     }
   }
 
   protected function willRunOneTest($test) {
     self::$distinctWillRunTests[$test] = true;
     self::$oneTestCounter++;
   }
 
   protected function didRunOneTest($test) {
     $this->assertEqual(
       1,
       self::$oneTestCounter,
       'Expect willRunOneTest depth to be one.');
 
     self::$distinctDidRunTests[$test] = true;
     self::$oneTestCounter--;
   }
 
   public function testPass() {
     $this->assertEqual(1, 1, 'This test is expected to pass.');
   }
 
   public function testFailSkip() {
     $failed = 0;
     $skipped = 0;
     $test_case = new ArcanistPhutilTestCaseTestCase();
     foreach ($test_case->run() as $result) {
       if ($result->getResult() == ArcanistUnitTestResult::RESULT_FAIL) {
         $failed++;
       } else if ($result->getResult() == ArcanistUnitTestResult::RESULT_SKIP) {
         $skipped++;
       } else {
         $this->assertFailure('These tests should either fail or skip.');
       }
     }
     $this->assertEqual(1, $failed, 'One test was expected to fail.');
     $this->assertEqual(1, $skipped, 'One test was expected to skip.');
   }
 
   public function testTryTestCases() {
     $this->tryTestCases(
       array(
         true,
         false,
       ),
       array(
         true,
         false,
       ),
       array($this, 'throwIfFalsey'));
   }
 
   public function testTryTestMap() {
     $this->tryTestCaseMap(
       array(
         1 => true,
         0 => false,
       ),
       array($this, 'throwIfFalsey'));
   }
 
   protected function throwIfFalsey($input) {
     if (!$input) {
       throw new Exception('This is a negative test case!');
     }
   }
 
 }
diff --git a/src/unit/engine/__tests__/XUnitTestResultParserTestCase.php b/src/unit/engine/__tests__/XUnitTestResultParserTestCase.php
index e2050c53..2157a80b 100644
--- a/src/unit/engine/__tests__/XUnitTestResultParserTestCase.php
+++ b/src/unit/engine/__tests__/XUnitTestResultParserTestCase.php
@@ -1,59 +1,54 @@
 <?php
 
 /**
  * Test for @{class:ArcanistXUnitTestResultParser}.
- *
- * (putting tests in your tests so you can test
- * while you test)
- *
- * @group testcase
  */
 final class XUnitTestResultParserTestCase extends ArcanistTestCase {
 
   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('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('Should throw on non-xml input');
     } catch (Exception $e) {
       // OK
     }
 
     $this->assertTrue(true);
   }
 
 }
diff --git a/src/unit/engine/phutil/ArcanistPhutilTestCase.php b/src/unit/engine/phutil/ArcanistPhutilTestCase.php
index 761323f6..96b9fdeb 100644
--- a/src/unit/engine/phutil/ArcanistPhutilTestCase.php
+++ b/src/unit/engine/phutil/ArcanistPhutilTestCase.php
@@ -1,706 +1,704 @@
 <?php
 
 /**
  * Base test case for the very simple libphutil test framework.
  *
  * @task assert       Making Test Assertions
  * @task exceptions   Exception Handling
  * @task hook         Hooks for Setup and Teardown
  * @task internal     Internals
  */
 abstract class ArcanistPhutilTestCase {
 
   private $assertions = 0;
   private $runningTest;
   private $testStartTime;
   private $results = array();
   private $enableCoverage;
   private $coverage = array();
   private $projectRoot;
   private $paths;
   private $renderer;
 
 
 /* -(  Making Test Assertions  )--------------------------------------------- */
 
 
   /**
    * Assert that a value is `false`, strictly. The test fails if it is not.
    *
    * @param wild    The empirically derived value, generated by executing the
    *                test.
    * @param string  A human-readable description of what these values represent,
    *                and particularly of what a discrepancy means.
    *
    * @return void
    * @task assert
    */
   final protected function assertFalse($result, $message = null) {
     if ($result === false) {
       $this->assertions++;
       return;
     }
 
     $this->failAssertionWithExpectedValue('false', $result, $message);
   }
 
 
   /**
    * Assert that a value is `true`, strictly. The test fails if it is not.
    *
    * @param wild    The empirically derived value, generated by executing the
    *                test.
    * @param string  A human-readable description of what these values represent,
    *                and particularly of what a discrepancy means.
    *
    * @return void
    * @task assert
    */
   final protected function assertTrue($result, $message = null) {
     if ($result === true) {
       $this->assertions++;
       return;
     }
 
     $this->failAssertionWithExpectedValue('true', $result, $message);
   }
 
 
   /**
    * Assert that two values are equal, strictly. The test fails if they are not.
    *
    * NOTE: This method uses PHP's strict equality test operator (`===`) to
    * compare values. This means values and types must be equal, key order must
    * be identical in arrays, and objects must be referentially identical.
    *
    * @param wild    The theoretically expected value, generated by careful
    *                reasoning about the properties of the system.
    * @param wild    The empirically derived value, generated by executing the
    *                test.
    * @param string  A human-readable description of what these values represent,
    *                and particularly of what a discrepancy means.
    *
    * @return void
    * @task assert
    */
   final protected function assertEqual($expect, $result, $message = null) {
     if ($expect === $result) {
       $this->assertions++;
       return;
     }
 
     $expect = PhutilReadableSerializer::printableValue($expect);
     $result = PhutilReadableSerializer::printableValue($result);
     $caller = self::getCallerInfo();
     $file = $caller['file'];
     $line = $caller['line'];
 
     if ($message !== null) {
       $output = pht(
         'Assertion failed, expected values to be equal (at %s:%d): %s',
         $file,
         $line,
         $message);
     } else {
       $output = pht(
         'Assertion failed, expected values to be equal (at %s:%d).',
         $file,
         $line);
     }
 
     $output .= "\n";
 
     if (strpos($expect, "\n") === false && strpos($result, "\n") === false) {
       $output .= "Expected: {$expect}\n";
       $output .= "  Actual: {$result}";
     } else {
       $output .= "Expected vs Actual Output Diff\n";
       $output .= ArcanistDiffUtils::renderDifferences(
         $expect,
         $result,
         $lines = 0xFFFF);
     }
 
     $this->failTest($output);
     throw new ArcanistPhutilTestTerminatedException($output);
   }
 
 
   /**
    * Assert an unconditional failure. This is just a convenience method that
    * better indicates intent than using dummy values with assertEqual(). This
    * causes test failure.
    *
    * @param   string  Human-readable description of the reason for test failure.
    * @return  void
    * @task    assert
    */
   final protected function assertFailure($message) {
     $this->failTest($message);
     throw new ArcanistPhutilTestTerminatedException($message);
   }
 
   /**
    * End this test by asserting that the test should be skipped for some
    * reason.
    *
    * @param   string  Reason for skipping this test.
    * @return  void
    * @task    assert
    */
   final protected function assertSkipped($message) {
     $this->skipTest($message);
     throw new ArcanistPhutilTestSkippedException($message);
   }
 
 
 /* -(  Exception Handling  )------------------------------------------------- */
 
 
   /**
    * This simplest way to assert exceptions are thrown.
    *
    * @param exception   The expected exception.
    * @param callable    The thing which throws the exception.
    *
    * @return void
    * @task exceptions
    */
   final protected function assertException($expected_exception_class,
                                            $callable) {
     $this->tryTestCases(
       array('assertException' => array()),
       array(false),
       $callable,
       $expected_exception_class);
   }
 
   /**
    * Straightforward method for writing unit tests which check if some block of
    * code throws an exception. For example, this allows you to test the
    * exception behavior of ##is_a_fruit()## on various inputs:
    *
    *    public function testFruit() {
    *      $this->tryTestCases(
    *        array(
    *          'apple is a fruit'    => new Apple(),
    *          'rock is not a fruit' => new Rock(),
    *        ),
    *        array(
    *          true,
    *          false,
    *        ),
    *        array($this, 'tryIsAFruit'),
    *        'NotAFruitException');
    *    }
    *
    *    protected function tryIsAFruit($input) {
    *      is_a_fruit($input);
    *    }
    *
    * @param map       Map of test case labels to test case inputs.
    * @param list      List of expected results, true to indicate that the case
    *                  is expected to succeed and false to indicate that the case
    *                  is expected to throw.
    * @param callable  Callback to invoke for each test case.
    * @param string    Optional exception class to catch, defaults to
    *                  'Exception'.
    * @return void
    * @task exceptions
    */
   final protected function tryTestCases(
     array $inputs,
     array $expect,
     $callable,
     $exception_class = 'Exception') {
 
     if (count($inputs) !== count($expect)) {
       $this->assertFailure(
         'Input and expectations must have the same number of values.');
     }
 
     $labels = array_keys($inputs);
     $inputs = array_values($inputs);
     $expecting = array_values($expect);
     foreach ($inputs as $idx => $input) {
       $expect = $expecting[$idx];
       $label  = $labels[$idx];
 
       $caught = null;
       try {
         call_user_func($callable, $input);
       } catch (Exception $ex) {
         if ($ex instanceof ArcanistPhutilTestTerminatedException) {
           throw $ex;
         }
         if (!($ex instanceof $exception_class)) {
           throw $ex;
         }
         $caught = $ex;
       }
 
       $actual = !($caught instanceof Exception);
 
       if ($expect === $actual) {
         if ($expect) {
           $message = "Test case '{$label}' did not throw, as expected.";
         } else {
           $message = "Test case '{$label}' threw, as expected.";
         }
       } else {
         if ($expect) {
           $message = "Test case '{$label}' was expected to succeed, but it ".
                      "raised an exception of class ".get_class($ex)." with ".
                      "message: ".$ex->getMessage();
         } else {
           $message = "Test case '{$label}' was expected to raise an ".
                      "exception, but it did not throw anything.";
         }
       }
 
       $this->assertEqual($expect, $actual, $message);
     }
   }
 
 
   /**
    * Convenience wrapper around @{method:tryTestCases} for cases where your
    * inputs are scalar. For example:
    *
    *    public function testFruit() {
    *      $this->tryTestCaseMap(
    *        array(
    *          'apple' => true,
    *          'rock'  => false,
    *        ),
    *        array($this, 'tryIsAFruit'),
    *        'NotAFruitException');
    *    }
    *
    *    protected function tryIsAFruit($input) {
    *      is_a_fruit($input);
    *    }
    *
    * For cases where your inputs are not scalar, use @{method:tryTestCases}.
    *
    * @param map       Map of scalar test inputs to expected success (true
    *                  expects success, false expects an exception).
    * @param callable  Callback to invoke for each test case.
    * @param string    Optional exception class to catch, defaults to
    *                  'Exception'.
    * @return void
    * @task exceptions
    */
   final protected function tryTestCaseMap(
     array $map,
     $callable,
     $exception_class = 'Exception') {
     return $this->tryTestCases(
       array_fuse(array_keys($map)),
       array_values($map),
       $callable,
       $exception_class);
   }
 
 
 /* -(  Hooks for Setup and Teardown  )--------------------------------------- */
 
 
   /**
    * This hook is invoked once, before any tests in this class are run. It
    * gives you an opportunity to perform setup steps for the entire class.
    *
    * @return void
    * @task hook
    */
   protected function willRunTests() {
     return;
   }
 
 
   /**
    * This hook is invoked once, after any tests in this class are run. It gives
    * you an opportunity to perform teardown steps for the entire class.
    *
    * @return void
    * @task hook
    */
   protected function didRunTests() {
     return;
   }
 
 
   /**
    * This hook is invoked once per test, before the test method is invoked.
    *
    * @param string Method name of the test which will be invoked.
    * @return void
    * @task hook
    */
   protected function willRunOneTest($test_method_name) {
     return;
   }
 
 
   /**
    * This hook is invoked once per test, after the test method is invoked.
    *
    * @param string Method name of the test which was invoked.
    * @return void
    * @task hook
    */
   protected function didRunOneTest($test_method_name) {
     return;
   }
 
 
   /**
    * This hook is invoked once, before any test cases execute. It gives you
    * an opportunity to perform setup steps for the entire suite of test cases.
    *
    * @param list<ArcanistPhutilTestCase> List of test cases to be run.
    * @return void
    * @task hook
    */
   public function willRunTestCases(array $test_cases) {
     return;
   }
 
 
   /**
    * This hook is invoked once, after all test cases execute.
    *
    * @param list<ArcanistPhutilTestCase> List of test cases that ran.
    * @return void
    * @task hook
    */
   public function didRunTestCases(array $test_cases) {
     return;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Construct a new test case. This method is ##final##, use willRunTests() to
    * provide test-wide setup logic.
    *
    * @task internal
    */
-  final public function __construct() {
-
-  }
+  final public function __construct() {}
 
 
   /**
    * Mark the currently-running test as a failure.
    *
    * @param string  Human-readable description of problems.
    * @return void
    *
    * @task internal
    */
   final private function failTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_FAIL, $reason);
   }
 
 
   /**
    * This was a triumph. I'm making a note here: HUGE SUCCESS.
    *
    * @param string  Human-readable overstatement of satisfaction.
    * @return void
    *
    * @task internal
    */
   final private function passTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_PASS, $reason);
   }
 
 
   /**
    * Mark the current running test as skipped.
    *
    * @param string  Description for why this test was skipped.
    * @return void
    * @task internal
    */
   final private function skipTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_SKIP, $reason);
   }
 
 
   final private function resultTest($test_result, $reason) {
     $coverage = $this->endCoverage();
 
     $result = new ArcanistUnitTestResult();
     $result->setCoverage($coverage);
     $result->setNamespace(get_class($this));
     $result->setName($this->runningTest);
     $result->setLink($this->getLink($this->runningTest));
     $result->setResult($test_result);
     $result->setDuration(microtime(true) - $this->testStartTime);
     $result->setUserData($reason);
     $this->results[] = $result;
 
     if ($this->renderer) {
       echo $this->renderer->renderUnitResult($result);
     }
   }
 
 
   /**
    * Execute the tests in this test case. You should not call this directly;
    * use @{class:PhutilUnitTestEngine} to orchestrate test execution.
    *
    * @return void
    * @task internal
    */
   final public function run() {
     $this->results = array();
 
     $reflection = new ReflectionClass($this);
     $methods = $reflection->getMethods();
 
     // Try to ensure that poorly-written tests which depend on execution order
     // (and are thus not properly isolated) will fail.
     shuffle($methods);
 
     $this->willRunTests();
     foreach ($methods as $method) {
       $name = $method->getName();
       if (preg_match('/^test/', $name)) {
         $this->runningTest = $name;
         $this->assertions = 0;
         $this->testStartTime = microtime(true);
 
         try {
           $this->willRunOneTest($name);
 
           $this->beginCoverage();
           $exceptions = array();
           try {
             call_user_func_array(
               array($this, $name),
               array());
             $this->passTest(pht('%d assertion(s) passed.', $this->assertions));
           } catch (Exception $ex) {
             $exceptions['Execution'] = $ex;
           }
 
           try {
             $this->didRunOneTest($name);
           } catch (Exception $ex) {
             $exceptions['Shutdown'] = $ex;
           }
 
           if ($exceptions) {
             if (count($exceptions) == 1) {
               throw head($exceptions);
             } else {
               throw new PhutilAggregateException(
                 'Multiple exceptions were raised during test execution.',
                 $exceptions);
             }
           }
 
           if (!$this->assertions) {
             $this->failTest(
               pht(
                 'This test case made no assertions. Test cases must make at '.
                 'least one assertion.'));
           }
 
         } catch (ArcanistPhutilTestTerminatedException $ex) {
           // Continue with the next test.
         } catch (ArcanistPhutilTestSkippedException $ex) {
           // Continue with the next test.
         } catch (Exception $ex) {
           $ex_class = get_class($ex);
           $ex_message = $ex->getMessage();
           $ex_trace = $ex->getTraceAsString();
           $message = "EXCEPTION ({$ex_class}): {$ex_message}\n{$ex_trace}";
           $this->failTest($message);
         }
       }
     }
     $this->didRunTests();
 
     return $this->results;
   }
 
   final public function setEnableCoverage($enable_coverage) {
     $this->enableCoverage = $enable_coverage;
     return $this;
   }
 
   /**
    * @phutil-external-symbol function xdebug_start_code_coverage
    */
   final private function beginCoverage() {
     if (!$this->enableCoverage) {
       return;
     }
 
     $this->assertCoverageAvailable();
     xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
   }
 
   /**
    * @phutil-external-symbol function xdebug_get_code_coverage
    * @phutil-external-symbol function xdebug_stop_code_coverage
    */
   final private function endCoverage() {
     if (!$this->enableCoverage) {
       return;
     }
 
     $result = xdebug_get_code_coverage();
     xdebug_stop_code_coverage($cleanup = false);
 
     $coverage = array();
 
     foreach ($result as $file => $report) {
       if (strncmp($file, $this->projectRoot, strlen($this->projectRoot))) {
         continue;
       }
 
       $max = max(array_keys($report));
       $str = '';
       for ($ii = 1; $ii <= $max; $ii++) {
         $c = idx($report, $ii);
         if ($c === -1) {
           $str .= 'U'; // Un-covered.
         } else if ($c === -2) {
           // TODO: This indicates "unreachable", but it flags the closing braces
           // of functions which end in "return", which is super ridiculous. Just
           // ignore it for now.
           //
           // See http://bugs.xdebug.org/view.php?id=1041
           $str .= 'N'; // Not executable.
         } else if ($c === 1) {
           $str .= 'C'; // Covered.
         } else {
           $str .= 'N'; // Not executable.
         }
       }
       $coverage[substr($file, strlen($this->projectRoot) + 1)] = $str;
     }
 
     // Only keep coverage information for files modified by the change. In
     // the case of --everything, we won't have paths, so just return all the
     // coverage data.
     if ($this->paths) {
       $coverage = array_select_keys($coverage, $this->paths);
     }
 
     return $coverage;
   }
 
   final private function assertCoverageAvailable() {
     if (!function_exists('xdebug_start_code_coverage')) {
       throw new Exception(
         "You've enabled code coverage but XDebug is not installed.");
     }
   }
 
   final public function setProjectRoot($project_root) {
     $this->projectRoot = $project_root;
     return $this;
   }
 
   final public function setPaths(array $paths) {
     $this->paths = $paths;
     return $this;
   }
 
   protected function getLink($method) {
     return null;
   }
 
   public function setRenderer(ArcanistUnitRenderer $renderer) {
     $this->renderer = $renderer;
     return $this;
   }
 
   /**
    * Returns info about the caller function.
    *
    * @return map
    */
   private static final function getCallerInfo() {
     $callee = array();
     $caller = array();
     $seen = false;
 
     foreach (array_slice(debug_backtrace(), 1) as $location) {
       $function = idx($location, 'function');
 
       if (!$seen && preg_match('/^assert[A-Z]/', $function)) {
         $seen = true;
         $caller = $location;
       } else if ($seen && !preg_match('/^assert[A-Z]/', $function)) {
         $callee = $location;
         break;
       }
     }
 
     return array(
       'file' => basename(idx($caller, 'file')),
       'line' => idx($caller, 'line'),
       'function' => idx($callee, 'function'),
       'class' => idx($callee, 'class'),
       'object' => idx($caller, 'object'),
       'type' => idx($callee, 'type'),
       'args' => idx($caller, 'args'),
     );
   }
 
 
   /**
    * Fail an assertion which checks that some result is equal to a specific
    * value, like 'true' or 'false'. This prints a readable error message and
    * fails the current test.
    *
    * This method throws and does not return.
    *
    * @param   string      Human readable description of the expected value.
    * @param   string      The actual value.
    * @param   string|null Optional assertion message.
    * @return  void
    * @task    internal
    */
   private function failAssertionWithExpectedValue(
     $expect_description,
     $actual_result,
     $message) {
 
     $caller = self::getCallerInfo();
     $file = $caller['file'];
     $line = $caller['line'];
 
     if ($message !== null) {
       $description = pht(
         "Assertion failed, expected '%s' (at %s:%d): %s",
         $expect_description,
         $file,
         $line,
         $message);
     } else {
       $description = pht(
         "Assertion failed, expected '%s' (at %s:%d).",
         $expect_description,
         $file,
         $line);
     }
 
     $actual_result = PhutilReadableSerializer::printableValue($actual_result);
     $header = pht('ACTUAL VALUE');
     $output = $description."\n\n".$header."\n".$actual_result;
 
     $this->failTest($output);
     throw new ArcanistPhutilTestTerminatedException($output);
   }
 
 }
diff --git a/src/unit/engine/phutil/testcase/ArcanistPhutilTestCaseTestCase.php b/src/unit/engine/phutil/testcase/ArcanistPhutilTestCaseTestCase.php
index 79cdb82e..dfe7a5ba 100644
--- a/src/unit/engine/phutil/testcase/ArcanistPhutilTestCaseTestCase.php
+++ b/src/unit/engine/phutil/testcase/ArcanistPhutilTestCaseTestCase.php
@@ -1,18 +1,16 @@
 <?php
 
 /**
  * Test for @{class:PhutilUnitTestEngineTestCase}.
- *
- * @group testcase
  */
 final class ArcanistPhutilTestCaseTestCase extends ArcanistPhutilTestCase {
 
   public function testFail() {
     $this->assertFailure('This test is expected to fail.');
   }
 
   public function testSkip() {
     $this->assertSkipped('This test is expected to skip.');
   }
 
 }
diff --git a/src/unit/engine/phutil/testcase/ArcanistPhutilTestSkippedException.php b/src/unit/engine/phutil/testcase/ArcanistPhutilTestSkippedException.php
index 24e48175..eaefe826 100644
--- a/src/unit/engine/phutil/testcase/ArcanistPhutilTestSkippedException.php
+++ b/src/unit/engine/phutil/testcase/ArcanistPhutilTestSkippedException.php
@@ -1,8 +1,6 @@
 <?php
 
 /**
  * Thrown to skip test execution.
- *
- * @group unitrun
  */
 final class ArcanistPhutilTestSkippedException extends Exception {}
diff --git a/src/unit/engine/phutil/testcase/ArcanistPhutilTestTerminatedException.php b/src/unit/engine/phutil/testcase/ArcanistPhutilTestTerminatedException.php
index 11d8b526..3a1a210e 100644
--- a/src/unit/engine/phutil/testcase/ArcanistPhutilTestTerminatedException.php
+++ b/src/unit/engine/phutil/testcase/ArcanistPhutilTestTerminatedException.php
@@ -1,8 +1,6 @@
 <?php
 
 /**
  * Thrown to prematurely end test execution.
- *
- * @group unitrun
  */
 final class ArcanistPhutilTestTerminatedException extends Exception {}
diff --git a/src/unit/renderer/ArcanistUnitConsoleRenderer.php b/src/unit/renderer/ArcanistUnitConsoleRenderer.php
index 99762e2d..0f93aad0 100644
--- a/src/unit/renderer/ArcanistUnitConsoleRenderer.php
+++ b/src/unit/renderer/ArcanistUnitConsoleRenderer.php
@@ -1,97 +1,94 @@
 <?php
 
-/**
- * @group unit
- */
 final class ArcanistUnitConsoleRenderer extends ArcanistUnitRenderer {
 
   public function renderUnitResult(ArcanistUnitTestResult $result) {
     $result_code = $result->getResult();
 
     $duration = '';
     if ($result_code == ArcanistUnitTestResult::RESULT_PASS) {
       $duration = ' '.$this->formatTestDuration($result->getDuration());
     }
 
     $test_name = $result->getName();
     $test_namespace = $result->getNamespace();
     if (strlen($test_namespace)) {
       $test_name = $test_namespace.'::'.$test_name;
     }
 
     $return = sprintf(
       "  %s %s\n",
       $this->getFormattedResult($result->getResult()).$duration,
       $test_name);
 
     if ($result_code != ArcanistUnitTestResult::RESULT_PASS) {
       $return .= $result->getUserData()."\n";
     }
 
     return $return;
   }
 
   public function renderPostponedResult($count) {
     return sprintf(
       "%s %s\n",
       $this->getFormattedResult(ArcanistUnitTestResult::RESULT_POSTPONED),
       pht('%d test(s)', $count));
   }
 
   private function getFormattedResult($result) {
     static $status_codes = array(
       ArcanistUnitTestResult::RESULT_PASS => '<bg:green>** PASS **</bg>',
       ArcanistUnitTestResult::RESULT_FAIL => '<bg:red>** FAIL **</bg>',
       ArcanistUnitTestResult::RESULT_SKIP => '<bg:yellow>** SKIP **</bg>',
       ArcanistUnitTestResult::RESULT_BROKEN => '<bg:red>** BROKEN **</bg>',
       ArcanistUnitTestResult::RESULT_UNSOUND => '<bg:yellow>** UNSOUND **</bg>',
       ArcanistUnitTestResult::RESULT_POSTPONED =>
         '<bg:yellow>** POSTPONED **</bg>',
     );
     return phutil_console_format($status_codes[$result]);
   }
 
   private function formatTestDuration($seconds) {
     // Very carefully define inclusive upper bounds on acceptable unit test
     // durations. Times are in milliseconds and are in increasing order.
     $star = "\xE2\x98\x85";
     if (phutil_is_windows()) {
       // Fall-back to normal asterisk for Windows consoles.
       $star = '*';
     }
     $acceptableness = array(
       50   => "<fg:green>%s</fg><fg:yellow>{$star}</fg> ",
       200  => '<fg:green>%s</fg>  ',
       500  => '<fg:yellow>%s</fg>  ',
       INF  => '<fg:red>%s</fg>  ',
     );
 
     $milliseconds = $seconds * 1000;
     $duration = $this->formatTime($seconds);
     foreach ($acceptableness as $upper_bound => $formatting) {
       if ($milliseconds <= $upper_bound) {
         return phutil_console_format($formatting, $duration);
       }
     }
     return phutil_console_format(end($acceptableness), $duration);
   }
 
   private function formatTime($seconds) {
     if ($seconds >= 60) {
       $minutes = floor($seconds / 60);
       return sprintf('%dm%02ds', $minutes, round($seconds % 60));
     }
 
     if ($seconds >= 1) {
       return sprintf('%4.1fs', $seconds);
     }
 
     $milliseconds = $seconds * 1000;
     if ($milliseconds >= 1) {
       return sprintf('%3dms', round($milliseconds));
     }
 
     return ' <1ms';
   }
 
 }
diff --git a/src/unit/renderer/ArcanistUnitRenderer.php b/src/unit/renderer/ArcanistUnitRenderer.php
index c4fcd954..3f798e83 100644
--- a/src/unit/renderer/ArcanistUnitRenderer.php
+++ b/src/unit/renderer/ArcanistUnitRenderer.php
@@ -1,11 +1,6 @@
 <?php
 
-/**
- * @group unit
- */
 abstract class ArcanistUnitRenderer {
-
   abstract public function renderUnitResult(ArcanistUnitTestResult $result);
   abstract public function renderPostponedResult($count);
-
 }
diff --git a/src/workflow/ArcanistAliasWorkflow.php b/src/workflow/ArcanistAliasWorkflow.php
index a53aa0b1..bc3a79a5 100644
--- a/src/workflow/ArcanistAliasWorkflow.php
+++ b/src/workflow/ArcanistAliasWorkflow.php
@@ -1,173 +1,171 @@
 <?php
 
 /**
  * Manages aliases for commands with options.
- *
- * @group workflow
  */
 final class ArcanistAliasWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'alias';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **alias**
       **alias** __command__
       **alias** __command__ __target__ -- [__options__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: cli
           Create an alias from __command__ to __target__ (optionally, with
           __options__). For example:
 
             arc alias fpatch patch -- --force
 
           ...will create a new 'arc' command, 'arc fpatch', which invokes
           'arc patch --force ...' when run. NOTE: use "--" before specifying
           options!
 
           If you start an alias with "!", the remainder of the alias will be
           invoked as a shell command. For example, if you want to implement
           'arc ls', you can do so like this:
 
             arc alias ls '!ls'
 
           You can now run "arc ls" and it will behave like "ls". Of course, this
           example is silly and would make your life worse.
 
           You can not overwrite builtins, including 'alias' itself. The builtin
           will always execute, even if it was added after your alias.
 
           To remove an alias, run:
 
             arc alias fpatch
 
           Without any arguments, 'arc alias' will list aliases.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'argv',
     );
   }
 
   public static function getAliases(
     ArcanistConfigurationManager $configuration_manager) {
 
     $working_copy_config_aliases =
       $configuration_manager->getProjectConfig('aliases');
     if (!$working_copy_config_aliases) {
       $working_copy_config_aliases = array();
     }
     $user_config_aliases = idx(
       $configuration_manager->readUserConfigurationFile(),
       'aliases',
       array());
     return $user_config_aliases + $working_copy_config_aliases;
   }
 
   private function writeAliases(array $aliases) {
     $config = $this->getConfigurationManager()->readUserConfigurationFile();
     $config['aliases'] = $aliases;
     $this->getConfigurationManager()->writeUserConfigurationFile($config);
   }
 
   public function run() {
     $aliases = self::getAliases($this->getConfigurationManager());
 
     $argv = $this->getArgument('argv');
     if (count($argv) == 0) {
       if ($aliases) {
         foreach ($aliases as $alias => $binding) {
           echo phutil_console_format(
             "**%s** %s\n",
             $alias,
             implode(' ' , $binding));
         }
       } else {
         echo "You haven't defined any aliases yet.\n";
       }
     } else if (count($argv) == 1) {
       if (empty($aliases[$argv[0]])) {
         echo "No alias '{$argv[0]}' to remove.\n";
       } else {
         echo phutil_console_format(
           "'**arc %s**' is currently aliased to '**arc %s**'.",
           $argv[0],
           implode(' ', $aliases[$argv[0]]));
         $ok = phutil_console_confirm('Delete this alias?');
         if ($ok) {
           $was = implode(' ', $aliases[$argv[0]]);
           unset($aliases[$argv[0]]);
           $this->writeAliases($aliases);
           echo "Unaliased '{$argv[0]}' (was '{$was}').\n";
         } else {
           throw new ArcanistUserAbortException();
         }
       }
     } else {
       $arc_config = $this->getArcanistConfiguration();
 
       if ($arc_config->buildWorkflow($argv[0])) {
         throw new ArcanistUsageException(
           "You can not create an alias for '{$argv[0]}' because it is a ".
           "builtin command. 'arc alias' can only create new commands.");
       }
 
       $aliases[$argv[0]] = array_slice($argv, 1);
       echo phutil_console_format(
         "Aliased '**arc %s**' to '**arc %s**'.\n",
         $argv[0],
         implode(' ', $aliases[$argv[0]]));
 
       $this->writeAliases($aliases);
     }
 
     return 0;
   }
 
   public static function isShellCommandAlias($command) {
     return preg_match('/^!/', $command);
   }
 
   public static function resolveAliases(
     $command,
     ArcanistConfiguration $config,
     array $argv,
     ArcanistConfigurationManager $configuration_manager) {
 
     $aliases = ArcanistAliasWorkflow::getAliases($configuration_manager);
     if (!isset($aliases[$command])) {
       return array(null, $argv);
     }
 
     $new_command = head($aliases[$command]);
 
     if (self::isShellCommandAlias($new_command)) {
       return array($new_command, $argv);
     }
 
     $workflow = $config->buildWorkflow($new_command);
     if (!$workflow) {
       return array(null, $argv);
     }
 
     $alias_argv = array_slice($aliases[$command], 1);
     foreach (array_reverse($alias_argv) as $alias_arg) {
       if (!in_array($alias_arg, $argv)) {
         array_unshift($argv, $alias_arg);
       }
     }
 
     return array($new_command, $argv);
   }
 
 }
diff --git a/src/workflow/ArcanistAnoidWorkflow.php b/src/workflow/ArcanistAnoidWorkflow.php
index 91793891..08974bde 100644
--- a/src/workflow/ArcanistAnoidWorkflow.php
+++ b/src/workflow/ArcanistAnoidWorkflow.php
@@ -1,32 +1,29 @@
 <?php
 
-/**
- * @group workflow
- */
 final class ArcanistAnoidWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'anoid';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **anoid**
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           There's only one way to find out...
 EOTEXT
       );
   }
 
   public function run() {
     phutil_passthru(
       '%s/scripts/breakout.py',
       dirname(phutil_get_library_root('arcanist')));
   }
 
 }
diff --git a/src/workflow/ArcanistBackoutWorkflow.php b/src/workflow/ArcanistBackoutWorkflow.php
index 91f202b2..caaf264f 100644
--- a/src/workflow/ArcanistBackoutWorkflow.php
+++ b/src/workflow/ArcanistBackoutWorkflow.php
@@ -1,182 +1,191 @@
 <?php
+
 /**
- * Runs git revert and assigns hi pri task to original author
- * @group workflow
+ * Runs git revert and assigns a high priority task to original author.
  */
-
 final class ArcanistBackoutWorkflow extends ArcanistBaseWorkflow {
+
   private $console;
   private $conduit;
   private $revision;
 
   public function getWorkflowName() {
     return 'backout';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **backout**
 EOTEXT
     );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Reverts/backouts on a previous commit. Supports: git
    Command is used like this: arc backout <commithash> | <diff revision>
    Entering a differential revision will only work if there is only one commit
    associated with the revision. This requires your working copy is up to date
    and that the commit exists in the working copy.
 EOTEXT
     );
   }
 
   public function getArguments() {
     return array(
       '*' => 'input',
     );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
-  // Given a differential revision ID, fetches the commit ID
+  /**
+   * Given a differential revision ID, fetches the commit ID.
+   */
   private function getCommitIDFromRevisionID($revision_id) {
     $conduit = $this->getConduit();
     $revisions = $conduit->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($revision_id),
       ));
     if (!$revisions) {
       throw new ArcanistUsageException(
         'The revision you provided does not exist!');
     }
     $revision = $revisions[0];
     $commits = $revision['commits'];
     if (!$commits) {
       throw new ArcanistUsageException(
         'This revision has not been committed yet!');
     }
     else if (count($commits) > 1) {
       throw new ArcanistUsageException(
         'The revision you provided has multiple commits!');
     }
     $commit_phid = $commits[0];
     $commit = $conduit->callMethodSynchronous(
       'phid.query',
       array(
         'phids' => array($commit_phid),
       ));
     $commit_id = $commit[$commit_phid]['name'];
     return $commit_id;
   }
 
-  // Fetches an array of commit info provided a Commit_id
-  // in the form of rE123456 (not local commit hash)
+  /**
+   * Fetches an array of commit info provided a Commit_id in the form of
+   * rE123456 (not local commit hash).
+   */
   private function getDiffusionCommit($commit_id) {
     $result = $this->getConduit()->callMethodSynchronous(
       'diffusion.getcommits',
       array(
         'commits' => array($commit_id),
       ));
     $commit = $result[$commit_id];
     // This commit was not found in Diffusion
     if (array_key_exists('error', $commit)) {
       return null;
     }
     return $commit;
   }
 
-  // Retrieves default template from differential and prefills info
+  /**
+   * Retrieves default template from differential and pre-fills info.
+   */
   private function buildCommitMessage($commit_hash) {
     $conduit = $this->getConduit();
     $repository_api = $this->getRepositoryAPI();
 
     $summary = $repository_api->getBackoutMessage($commit_hash);
-    $fields = array('summary' => $summary,
-                    'testPlan' => 'revert-hammer',
-                   );
+    $fields = array(
+      'summary' => $summary,
+      'testPlan' => 'revert-hammer',
+    );
     $template = $conduit->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => null,
         'edit'        => 'create',
         'fields'      => $fields
         ));
     $template = $this->newInteractiveEditor($template)
       ->setName('new-commit')
       ->editInteractively();
     return $template;
   }
 
-  // Performs the backout/revert of a revision and creates a commit
+  /**
+   * Performs the backout/revert of a revision and creates a commit.
+   */
   public function run() {
     $console = PhutilConsole::getConsole();
     $conduit = $this->getConduit();
     $repository_api = $this->getRepositoryAPI();
 
     $is_git_svn = $repository_api instanceof ArcanistGitAPI &&
                   $repository_api->isGitSubversionRepo();
     $is_hg_svn = $repository_api instanceof ArcanistMercurialAPI &&
-                  $repository_api->isHgSubversionRepo();
+                 $repository_api->isHgSubversionRepo();
     $revision_id = null;
 
     if (!($repository_api instanceof ArcanistGitAPI) &&
         !($repository_api instanceof ArcanistMercurialAPI)) {
       throw new ArcanistUsageException(
         'Backout currently only supports Git and Mercurial'
       );
     }
 
     $console->writeOut("Starting backout\n");
     $input = $this->getArgument('input');
     if (!$input || count($input) != 1) {
       throw new ArcanistUsageException(
         'You must specify one commit to backout!');
     }
 
     // Input looks like a Differential revision, so
     // we try to find the commit attached to it
     $matches = array();
     if (preg_match('/^D(\d+)$/i', $input[0], $matches)) {
       $revision_id = $matches[1];
       $commit_id = $this->getCommitIDFromRevisionID($revision_id);
       $commit = $this->getDiffusionCommit($commit_id);
       $commit_hash = $commit['commitIdentifier'];
       // Convert commit hash from SVN to Git/HG (for FB case)
       if ($is_git_svn || $is_hg_svn) {
         $commit_hash = $repository_api->
           getHashFromFromSVNRevisionNumber($commit_hash);
       }
     } else {
       // Assume input is a commit hash
       $commit_hash = $input[0];
     }
     if (!$repository_api->hasLocalCommit($commit_hash)) {
-      throw new ArcanistUsageException('Invalid commit provided or does not'.
-                                        'exist in the working copy!');
+      throw new ArcanistUsageException(
+        'Invalid commit provided or does not exist in the working copy!');
     }
 
     // Run 'backout'.
     $subject = $repository_api->getCommitSummary($commit_hash);
     $console->writeOut("Backing out commit {$commit_hash} {$subject} \n");
 
     $repository_api->backoutCommit($commit_hash);
 
     // Create commit message and execute the commit
     $message = $this->buildCommitMessage($commit_hash);
     $repository_api->doCommit($message);
     $console->writeOut("Double-check the commit and push when ready\n");
-
   }
+
 }
diff --git a/src/workflow/ArcanistBaseWorkflow.php b/src/workflow/ArcanistBaseWorkflow.php
index b7adcaea..16a2c216 100644
--- a/src/workflow/ArcanistBaseWorkflow.php
+++ b/src/workflow/ArcanistBaseWorkflow.php
@@ -1,1791 +1,1791 @@
 <?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
  *
  * @stable
  */
 abstract class ArcanistBaseWorkflow extends Phobject {
 
   const COMMIT_DISABLE = 0;
   const COMMIT_ALLOW = 1;
   const COMMIT_ENABLE = 2;
 
   const AUTO_COMMIT_TITLE = 'Automatic commit by arc';
 
   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 $workingCopy;
   private $arguments;
   private $passedArguments;
   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() {
-
-  }
+  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(
         '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(
         'You must specify a Conduit URI with setConduitURI() before you can '.
         'establish a conduit.');
     }
 
     $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(
         '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(
           'Set conduit credentials with setConduitCredentials() before '.
           'authenticating conduit!');
       }
 
       if (empty($credentials['user'])) {
-        throw new ConduitClientException('ERR-INVALID-USER',
-                                         'Empty user in credentials.');
+        throw new ConduitClientException(
+          'ERR-INVALID-USER',
+          'Empty user in credentials.');
       }
       if (empty($credentials['certificate'])) {
-        throw new ConduitClientException('ERR-NO-CERTIFICATE',
-                                         'Empty certificate in credentials.');
+        throw new ConduitClientException(
+          'ERR-NO-CERTIFICATE',
+          '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') {
         $conduit_uri = $this->conduitURI;
         $message =
           "\n".
           phutil_console_format(
             'YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR').
           "\n\n".
           phutil_console_format(
             '    To do this, run: **arc install-certificate**').
           "\n\n".
           "The server '{$conduit_uri}' rejected your request:".
           "\n".
           $ex->getMessage();
         throw new ArcanistUsageException($message);
       } else if ($ex->getErrorCode() == 'NEW-ARC-VERSION') {
 
         // Cleverly disguise this as being AWESOME!!!
 
         echo phutil_console_format("**New Version Available!**\n\n");
         echo phutil_console_wrap($ex->getMessage());
         echo "\n\n";
         echo "In most cases, arc can be upgraded automatically.\n";
 
         $ok = phutil_console_confirm(
           '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 "\nTry 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(
         "This workflow ('{$workflow}') requires authentication, override ".
         "requiresAuthentication() to return true.");
     }
     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(
         "This workflow ('{$workflow}') requires a Conduit, override ".
         "requiresConduit() to return true.");
     }
     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;
     }
 
     if ($this->workingCopy) {
       $workflow->setWorkingCopy($this->workingCopy);
     }
 
     $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();
     for ($ii = 0; $ii < count($args); $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);
         if (!array_key_exists($arg_key, $spec)) {
           $corrected = ArcanistConfiguration::correctArgumentSpelling(
             $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 'arc help'.",
               $arg_key));
           }
         }
       } 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 'arc help'.",
             $arg_key));
         }
         $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 == count($args) - 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 'arc help'.",
           $example));
       }
     }
 
     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(
             "Arguments '--{$key}' and '--{$conflict}' are mutually exclusive".
             $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(
         "This workflow ('{$workflow}') requires a working copy, override ".
         "requiresWorkingCopy() to return true.");
     }
     return $working_copy;
   }
 
   final public function setWorkingCopy(
     ArcanistWorkingCopyIdentity $working_copy) {
     $this->workingCopy = $working_copy;
     return $this;
   }
 
   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(
         "This workflow ('{$workflow}') requires a Repository API, override ".
         "requiresRepositoryAPI() to return true.");
     }
     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(
       "  Working copy: __%s__\n\n",
       $api->getPath());
 
     $untracked = $api->getUntrackedChanges();
     if ($this->shouldRequireCleanUntrackedFiles()) {
 
       if (!empty($untracked)) {
         echo "You have untracked files in this working copy.\n\n".
              $working_copy_desc.
              "  Untracked files in working copy:\n".
              "    ".implode("\n    ", $untracked)."\n\n";
 
         if ($api instanceof ArcanistGitAPI) {
           echo phutil_console_wrap(
             "Since you don't have '.gitignore' rules for these files and have ".
             "not listed them in '.git/info/exclude', you may have forgotten ".
             "to 'git add' them to your commit.\n");
         } else if ($api instanceof ArcanistSubversionAPI) {
           echo phutil_console_wrap(
             "Since you don't have 'svn:ignore' rules for these files, you may ".
             "have forgotten to 'svn add' them.\n");
         } else if ($api instanceof ArcanistMercurialAPI) {
           echo phutil_console_wrap(
             "Since you don't have '.hgignore' rules for these files, you ".
             "may have forgotten to 'hg add' them to your commit.\n");
         }
 
         if ($this->askForAdd($untracked)) {
           $api->addToCommit($untracked);
           $must_commit += array_flip($untracked);
         } else if ($this->commitMode == self::COMMIT_DISABLE) {
           $prompt = $this->getAskForAddPrompt($untracked);
           if (phutil_console_confirm($prompt)) {
             throw new ArcanistUsageException(pht(
               "Add these files and then run 'arc %s' again.",
               $this->getWorkflowName()));
           }
         }
 
       }
     }
 
     // NOTE: this is a subversion-only concept.
     $incomplete = $api->getIncompleteChanges();
     if ($incomplete) {
       throw new ArcanistUsageException(
         "You have incompletely checked out directories in this working copy. ".
         "Fix them before proceeding.\n\n".
         $working_copy_desc.
         "  Incomplete directories in working copy:\n".
         "    ".implode("\n    ", $incomplete)."\n\n".
         "You can fix these paths by running 'svn update' on them.");
     }
 
     $conflicts = $api->getMergeConflicts();
     if ($conflicts) {
       throw new ArcanistUsageException(
         "You have merge conflicts in this working copy. Resolve merge ".
         "conflicts before proceeding.\n\n".
         $working_copy_desc.
         "  Conflicts in working copy:\n".
         "    ".implode("\n    ", $conflicts)."\n");
     }
 
     $missing = $api->getMissingChanges();
     if ($missing) {
       throw new ArcanistUsageException(
         pht(
           "You have missing files in this working copy. Revert or formally ".
           "remove them (with `svn rm`) before proceeding.\n\n".
           "%s".
           "  Missing files in working copy:\n%s\n",
           $working_copy_desc,
           "    ".implode("\n    ", $missing)));
     }
 
     $unstaged = $api->getUnstagedChanges();
     if ($unstaged) {
       echo "You have unstaged changes in this working copy.\n\n".
         $working_copy_desc.
         "  Unstaged changes in working copy:\n".
         "    ".implode("\n    ", $unstaged)."\n";
       if ($this->askForAdd($unstaged)) {
         $api->addToCommit($unstaged);
         $must_commit += array_flip($unstaged);
       } else {
         $permit_autostash = $this->getConfigFromAnySource(
           'arc.autostash',
           false);
         if ($permit_autostash && $api->canStashChanges()) {
           echo "Stashing uncommitted changes. (You can restore them with ".
                "`git stash pop`.)\n";
           $api->stashChanges();
           $this->stashed = true;
         } else {
           throw new ArcanistUsageException(
             'Stage and commit (or revert) them before proceeding.');
         }
       }
     }
 
     $uncommitted = $api->getUncommittedChanges();
     foreach ($uncommitted as $key => $path) {
       if (array_key_exists($path, $must_commit)) {
         unset($uncommitted[$key]);
       }
     }
     if ($uncommitted) {
       echo "You have uncommitted changes in this working copy.\n\n".
         $working_copy_desc.
         "  Uncommitted changes in working copy:\n".
         "    ".implode("\n    ", $uncommitted)."\n";
       if ($this->askForAdd($uncommitted)) {
         $must_commit += array_flip($uncommitted);
       } else {
         throw new ArcanistUncommittedChangesException(
           'Commit (or revert) them before proceeding.');
       }
     }
 
     if ($must_commit) {
       if ($this->getShouldAmend()) {
         $commit = head($api->getLocalCommitInformation());
         $api->amendCommit($commit['message']);
       } else if ($api->supportsLocalCommits()) {
         $commit_message = phutil_console_prompt('Enter commit message:');
         if ($commit_message == '') {
           $commit_message = self::AUTO_COMMIT_TITLE;
         }
         $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.
 
     $repository = $this->loadProjectRepository();
     if ($repository) {
       $callsign = $repository['callsign'];
       $known_commits = $this->getConduit()->callMethodSynchronous(
         'diffusion.getcommits',
         array('commits' => array('r'.$callsign.$commit['commit'])));
       if (ifilter($known_commits, 'error', $negate = true)) {
         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 files to the commit?',
         count($files));
     } else {
       $prompt = pht(
         'Do you want to add these files to the commit?',
         count($files));
     }
     return $prompt;
   }
 
   final protected function loadDiffBundleFromConduit(
     ConduitClient $conduit,
     $diff_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'diff_id' => $diff_id,
     ));
   }
 
   final protected function loadRevisionBundleFromConduit(
     ConduitClient $conduit,
     $revision_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'revision_id' => $revision_id,
     ));
   }
 
   final private function loadBundleFromConduit(
     ConduitClient $conduit,
     $params) {
 
     $future = $conduit->callMethod('differential.getdiff', $params);
     $diff = $future->resolve();
 
     $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->setProjectID(idx($diff, 'projectName'));
     $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('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('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(
           "Trying to get change for unchanged path '{$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(
             "Option '--{$arg}' is not supported under {$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();
   }
 
   protected function getSupportedRevisionControlSystems() {
     return array('any');
   }
 
   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 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
    * specfifying 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("Path '{$path}' does not exist!");
         }
         $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 json_decode($file, true);
   }
 
 
   /**
    * 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() {
     $default = 'UTF-8';
     return nonempty(idx($this->getProjectInfo(), 'encoding'), $default);
   }
 
   final protected function getProjectInfo() {
     if ($this->projectInfo === null) {
       $project_id = $this->getWorkingCopy()->getProjectID();
       if (!$project_id) {
         $this->projectInfo = array();
       } else {
         try {
           $this->projectInfo = $this->getConduit()->callMethodSynchronous(
             'arcanist.projectinfo',
             array(
               'name' => $project_id,
             ));
         } catch (ConduitClientException $ex) {
           if ($ex->getErrorCode() != 'ERR-BAD-ARCANIST-PROJECT') {
             throw $ex;
           }
 
           // TODO: Implement a proper query method that doesn't throw on
           // project not found. We just swallow this because some pathways,
           // like Git with uncommitted changes in a repository with a new
           // project ID, may attempt to access project information before
           // the project is created. See T2153.
           return array();
         }
       }
     }
 
     return $this->projectInfo;
   }
 
   final protected function loadProjectRepository() {
     $project = $this->getProjectInfo();
     if (isset($project['repository'])) {
       return $project['repository'];
     }
     // NOTE: The rest of the code is here for backwards compatibility.
 
     $repository_phid = idx($project, 'repositoryPHID');
     if (!$repository_phid) {
       return array();
     }
 
     $repositories = $this->getConduit()->callMethodSynchronous(
       'repository.query',
       array());
     $repositories = ipull($repositories, null, 'phid');
 
     return idx($repositories, $repository_phid, 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(
           "This feature requires a newer version of Phabricator. Please ".
           "update it using these instructions: ".
           "http://www.phabricator.com/docs/phabricator/article/".
           "Installation_Guide.html#updating-phabricator\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(
         'This version control system does not support commit ranges.');
     }
 
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         '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 callsign of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository callsign, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryCallsign() {
     return idx($this->getRepositoryInformation(), 'callsign');
   }
 
 
   /**
    * 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');
   }
 
 
   /**
    * 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 "repository.callsign" to select a repository '.
         'explicitly.');
     } else if (count($results) > 1) {
       $reasons[] = pht(
         'Multiple repostories (%s) matched the query. You can use the '.
         '"repository.callsign" configuration to select the one you want.',
         implode(', ', ipull($results, '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 "repository.callsign" is set to "%s".',
         $callsign);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'Configuration value "repository.callsign" is empty.');
     }
 
     $project_info = $this->getProjectInfo();
     $project_name = $this->getWorkingCopy()->getProjectID();
     if ($this->getProjectInfo()) {
       if (!empty($project_info['repository']['callsign'])) {
         $callsign = $project_info['repository']['callsign'];
         $query = array(
           'callsigns' => array($callsign),
         );
         $reasons[] = pht(
           'Configuration value "project.name" is set to "%s"; this project '.
           'is associated with the "%s" repository.',
           $project_name,
           $callsign);
         return array($query, $reasons);
       } else {
         $reasons[] = pht(
           'Configuration value "project.name" is set to "%s", but this '.
           'project is not associated with a repository.',
           $project_name);
       }
     } else if (strlen($project_name)) {
       $reasons[] = pht(
         'Configuration value "project.name" is set to "%s", but that '.
         'project does not exist.',
         $project_name);
     } else {
       $reasons[] = pht(
         'Configuration value "project.name" is empty.');
     }
 
     $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 '.arclint' file, or configure an advanced engine ".
           "with 'lint.engine' in '.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;
   }
 
 }
diff --git a/src/workflow/ArcanistBookmarkWorkflow.php b/src/workflow/ArcanistBookmarkWorkflow.php
index edf9ef7f..16c71acc 100644
--- a/src/workflow/ArcanistBookmarkWorkflow.php
+++ b/src/workflow/ArcanistBookmarkWorkflow.php
@@ -1,39 +1,37 @@
 <?php
 
 /**
- * Alias for arc feature
- *
- * @group workflow
+ * Alias for `arc feature`.
  */
 final class ArcanistBookmarkWorkflow extends ArcanistFeatureWorkflow {
 
   public function getWorkflowName() {
     return 'bookmark';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **bookmark** [__options__]
       **bookmark** __name__ [__start__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: hg
           Alias for arc feature.
 EOTEXT
       );
   }
 
   public function run() {
     $repository_api = $this->getRepositoryAPI();
     if (!($repository_api instanceof ArcanistMercurialAPI)) {
       throw new ArcanistUsageException(
         'arc bookmark is only supported under Mercurial.');
     }
     return parent::run();
   }
 
 }
diff --git a/src/workflow/ArcanistBranchWorkflow.php b/src/workflow/ArcanistBranchWorkflow.php
index 0ec4dc26..29d3b7b1 100644
--- a/src/workflow/ArcanistBranchWorkflow.php
+++ b/src/workflow/ArcanistBranchWorkflow.php
@@ -1,39 +1,37 @@
 <?php
 
 /**
- * Alias for arc feature
- *
- * @group workflow
+ * Alias for `arc feature`.
  */
 final class ArcanistBranchWorkflow extends ArcanistFeatureWorkflow {
 
   public function getWorkflowName() {
     return 'branch';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **branch** [__options__]
       **branch** __name__ [__start__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git
           Alias for arc feature.
 EOTEXT
       );
   }
 
   public function run() {
     $repository_api = $this->getRepositoryAPI();
     if (!($repository_api instanceof ArcanistGitAPI)) {
       throw new ArcanistUsageException(
         'arc branch is only supported under Git.');
     }
     return parent::run();
   }
 
 }
diff --git a/src/workflow/ArcanistBrowseWorkflow.php b/src/workflow/ArcanistBrowseWorkflow.php
index 42d874fa..606541a0 100644
--- a/src/workflow/ArcanistBrowseWorkflow.php
+++ b/src/workflow/ArcanistBrowseWorkflow.php
@@ -1,140 +1,141 @@
 <?php
 
 /**
  * Browse files in the Diffusion web interface.
  */
 final class ArcanistBrowseWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'browse';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **browse** [__options__] __path__ ...
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg, svn
           Browse files in the Diffusion web interface.
 
           Set the 'browser' value using 'arc set-config' to select a browser. If
           no browser is set, the command will try to guess which browser to use.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'branch' => array(
         'param' => 'branch_name',
         'help' => pht(
           'Default branch name to view on server. Defaults to "master".'),
       ),
       '*' => 'paths',
     );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function run() {
     $repository_api = $this->getRepositoryAPI();
     $project_root = $this->getWorkingCopy()->getProjectRoot();
 
     $in_paths = $this->getArgument('paths');
     if (!$in_paths) {
       throw new ArcanistUsageException(
         pht(
           'Specify one or more paths to browse. Use the command '.
           '"arc browse ." if you want to browse this directory.'));
     }
 
     $paths = array();
     foreach ($in_paths as $key => $path) {
       $path = preg_replace('/:([0-9]+)$/', '$\1', $path);
       $full_path = Filesystem::resolvePath($path);
 
       if ($full_path == $project_root) {
         $paths[$key] = '';
       } else {
         $paths[$key] = Filesystem::readablePath($full_path, $project_root);
       }
     }
 
     $base_uri = $this->getBaseURI();
     $browser = $this->getBrowserCommand();
 
     foreach ($paths as $path) {
       $ret_code = phutil_passthru('%s %s', $browser, $base_uri.$path);
       if ($ret_code) {
         throw new ArcanistUsageException(
           "It seems we failed to open the browser; perhaps you should try to ".
           "set the 'browser' config option. The command we tried to use was: ".
           $browser);
       }
     }
 
     return 0;
   }
 
   private function getBaseURI() {
     $repo_uri = $this->getRepositoryURI();
     if ($repo_uri === null) {
       throw new ArcanistUsageException(
         pht(
           'arc is unable to determine which repository in Diffusion '.
           'this working copy belongs to. Use "arc which" to understand how '.
           'arc looks for a repository.'));
     }
 
     $branch = $this->getArgument('branch', 'master');
 
     return $repo_uri.'browse/'.$branch.'/';
   }
 
   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 'browser' in your ".
         "arc config to specify one."));
   }
+
 }
diff --git a/src/workflow/ArcanistCallConduitWorkflow.php b/src/workflow/ArcanistCallConduitWorkflow.php
index 17f77890..ff07ac38 100644
--- a/src/workflow/ArcanistCallConduitWorkflow.php
+++ b/src/workflow/ArcanistCallConduitWorkflow.php
@@ -1,94 +1,93 @@
 <?php
 
 /**
  * Provides command-line access to the Conduit API.
- *
- * @group workflow
  */
 final class ArcanistCallConduitWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'call-conduit';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **call-conduit** __method__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: http, https
           Allows you to make a raw Conduit method call:
 
             - Run this command from a working directory.
             - Call parameters are REQUIRED and read as a JSON blob from stdin.
             - Results are written to stdout as a JSON blob.
 
           This workflow is primarily useful for writing scripts which integrate
           with Phabricator. Examples:
 
             $ echo '{}' | arc call-conduit conduit.ping
             $ echo '{"phid":"PHID-FILE-xxxx"}' | arc call-conduit file.download
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'method',
     );
   }
 
   public function shouldShellComplete() {
     return false;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function run() {
     $method = $this->getArgument('method', array());
     if (count($method) !== 1) {
       throw new ArcanistUsageException(
         'Provide exactly one Conduit method name.');
     }
     $method = reset($method);
 
     $console = PhutilConsole::getConsole();
     $console->writeErr("%s\n", pht('Waiting for JSON parameters on stdin...'));
     $params = @file_get_contents('php://stdin');
     $params = json_decode($params, true);
     if (!is_array($params)) {
       throw new ArcanistUsageException(
         'Provide method parameters on stdin as a JSON blob.');
     }
 
     $error = null;
     $error_message = null;
     try {
       $result = $this->getConduit()->callMethodSynchronous(
         $method,
         $params);
     } catch (ConduitClientException $ex) {
       $error = $ex->getErrorCode();
       $error_message = $ex->getMessage();
       $result = null;
     }
 
     echo json_encode(array(
       'error'         => $error,
       'errorMessage'  => $error_message,
       'response'      => $result,
     ))."\n";
 
     return 0;
   }
+
 }
diff --git a/src/workflow/ArcanistCloseRevisionWorkflow.php b/src/workflow/ArcanistCloseRevisionWorkflow.php
index 89692c0e..5c6088b1 100644
--- a/src/workflow/ArcanistCloseRevisionWorkflow.php
+++ b/src/workflow/ArcanistCloseRevisionWorkflow.php
@@ -1,154 +1,153 @@
 <?php
 
 /**
  * Explicitly closes Differential revisions.
- *
- * @group workflow
  */
 final class ArcanistCloseRevisionWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'close-revision';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **close-revision** [__options__] __revision__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg, svn
           Close a revision which has been committed (svn) or pushed (git, hg).
           You should not normally need to do this: arc commit (svn), arc amend
           (git, hg), arc land (git, hg), or repository tracking on the master
           remote repository should do it for you. However, if these mechanisms
           have failed for some reason you can use this command to manually
           change a revision status from "Accepted" to "Closed".
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'finalize' => array(
         'help' =>
           "Close only if the repository is untracked and the revision is ".
           "accepted. Continue even if the close can't happen. This is a soft ".
           "version of 'close-revision' used by other workflows.",
       ),
       'quiet' => array(
         'help' =>  'Do not print a success message.',
       ),
       '*' => 'revision',
     );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     // NOTE: Technically we only use this to generate the right message at
     // the end, and you can even get the wrong message (e.g., if you run
     // "arc close-revision D123" from a git repository, but D123 is an SVN
     // revision). We could be smarter about this, but it's just display fluff.
     return true;
   }
 
   public function run() {
     $is_finalize = $this->getArgument('finalize');
 
     $conduit = $this->getConduit();
 
     $revision_list = $this->getArgument('revision', array());
     if (!$revision_list) {
       throw new ArcanistUsageException(
         'close-revision requires a revision number.');
     }
     if (count($revision_list) != 1) {
       throw new ArcanistUsageException(
         'close-revision requires exactly one revision.');
     }
     $revision_id = reset($revision_list);
     $revision_id = $this->normalizeRevisionID($revision_id);
 
     $revisions = $conduit->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($revision_id),
       ));
     $revision = head($revisions);
 
     if (!$revision && !$is_finalize) {
       throw new ArcanistUsageException(
         "Revision D{$revision_id} does not exist."
       );
     }
 
     $status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
     $status_closed   = ArcanistDifferentialRevisionStatus::CLOSED;
 
     if (!$is_finalize && $revision['status'] != $status_accepted) {
       throw new ArcanistUsageException(
         "Revision D{$revision_id} can not be closed. You can only close ".
         "revisions which have been 'accepted'.");
     }
 
     if ($revision) {
       if (!$is_finalize && $revision['authorPHID'] != $this->getUserPHID()) {
         $prompt = "You are not the author of revision D{$revision_id}, ".
           'are you sure you want to close it?';
         if (!phutil_console_confirm($prompt)) {
           throw new ArcanistUserAbortException();
         }
       }
 
       $actually_close = true;
       if ($is_finalize) {
         if ($this->getRepositoryPHID() ||
             $revision['status'] != $status_accepted) {
           $actually_close = false;
         }
       }
       if ($actually_close) {
         $revision_name = $revision['title'];
 
         echo "Closing revision D{$revision_id} '{$revision_name}'...\n";
 
         $conduit->callMethodSynchronous(
           'differential.close',
           array(
             'revisionID' => $revision_id,
           ));
       }
     }
 
     $status = $revision['status'];
     if ($status == $status_accepted || $status == $status_closed) {
       // If this has already been attached to commits, don't show the
       // "you can push this commit" message since we know it's been pushed
       // already.
       $is_finalized = empty($revision['commits']);
     } else {
       $is_finalized = false;
     }
 
     if (!$this->getArgument('quiet')) {
       if ($is_finalized) {
         $message = $this->getRepositoryAPI()->getFinalizedRevisionMessage();
         echo phutil_console_wrap($message)."\n";
       } else {
         echo "Done.\n";
       }
     }
 
     return 0;
   }
+
 }
diff --git a/src/workflow/ArcanistCloseWorkflow.php b/src/workflow/ArcanistCloseWorkflow.php
index 5c62e3e7..857d6298 100644
--- a/src/workflow/ArcanistCloseWorkflow.php
+++ b/src/workflow/ArcanistCloseWorkflow.php
@@ -1,147 +1,146 @@
 <?php
 
 /**
- * Close a task
- *
- * @group workflow
+ * Close a task.
  */
 final class ArcanistCloseWorkflow extends ArcanistBaseWorkflow {
 
   private $tasks;
   private $statusOptions;
   private $statusData;
 
   private function loadStatusData() {
     $this->statusData = $this->getConduit()->callMethodSynchronous(
       'maniphest.querystatuses',
       array());
     return $this;
   }
 
   private function getStatusOptions() {
     if ($this->statusData === null) {
       throw new Exception('loadStatusData first!');
     }
     return idx($this->statusData, 'statusMap');
   }
   private function getDefaultClosedStatus() {
     if ($this->statusData === null) {
       throw new Exception('loadStatusData first!');
     }
     return idx($this->statusData, 'defaultClosedStatus');
   }
 
   public function getWorkflowName() {
     return 'close';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **close** __task_id__ [__options__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
         Close a task or otherwise update its status.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return false;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
 
   public function getArguments() {
     return array(
       '*' => 'task_id',
       'message' => array(
         'short' => 'm',
         'param' => 'comment',
         'help'  => pht('Provide a comment with your status change.'),
       ),
       'status'  => array(
         'param' => 'status',
         'short' => 's',
-        'help'  => pht('Specify a new status. Valid status options can be '.
-                       'seen with the `list-statuses` argument.'),
+        'help'  => pht(
+          'Specify a new status. Valid status options can be '.
+          'seen with the `list-statuses` argument.'),
       ),
       'list-statuses' => array(
         'help' => 'Show available status options and exit.',
       ),
     );
   }
 
   public function run() {
     $this->loadStatusData();
     $list_statuses = $this->getArgument('list-statuses');
     if ($list_statuses) {
       echo phutil_console_format(pht(
         "Valid status options are:\n".
         "\t%s\n", implode($this->getStatusOptions(), ', ')));
       return 0;
     }
     $ids = $this->getArgument('task_id');
     $message = $this->getArgument('message');
     $status = strtolower($this->getArgument('status'));
 
     $status_options = $this->getStatusOptions();
     if (!isset($status) || $status == '') {
       $status = $this->getDefaultClosedStatus();
     }
 
     if (!isset($status_options[$status])) {
       $options = array_keys($status_options);
       $last = array_pop($options);
       echo "Invalid status {$status}, valid options are ".
         implode(', ', $options).", or {$last}.\n";
       return;
     }
 
     foreach ($ids as $id) {
       if (!preg_match('/^T?\d+$/', $id)) {
         echo "Invalid Task ID: {$id}.\n";
         return 1;
       }
       $id = ltrim($id, 'T');
       $result = $this->closeTask($id, $status, $message);
       $current_status = $status_options[$status];
       if ($result) {
         echo "T{$id}'s status is now set to {$current_status}.\n";
       } else {
         echo "T{$id} is already set to {$current_status}.\n";
       }
     }
     return 0;
   }
 
   private function closeTask($task_id, $status, $comment = '') {
     $conduit = $this->getConduit();
     $info = $conduit->callMethodSynchronous(
       'maniphest.info',
       array(
         'task_id' => $task_id
       ));
     if ($info['status'] == $status) {
       return false;
     }
     return $conduit->callMethodSynchronous(
       'maniphest.update',
       array(
         'id' => $task_id,
         'status' => $status,
         'comments' => $comment
       ));
   }
 
 }
diff --git a/src/workflow/ArcanistCommitWorkflow.php b/src/workflow/ArcanistCommitWorkflow.php
index 24e68868..b8cf6c6b 100644
--- a/src/workflow/ArcanistCommitWorkflow.php
+++ b/src/workflow/ArcanistCommitWorkflow.php
@@ -1,340 +1,337 @@
 <?php
 
 /**
  * Executes "svn commit" once a revision has been "Accepted".
- *
- * @group workflow
  */
 final class ArcanistCommitWorkflow extends ArcanistBaseWorkflow {
 
   private $revisionID;
 
   public function getWorkflowName() {
     return 'commit';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **commit** [--revision __revision_id__] [--show]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn
           Commit a revision which has been accepted by a reviewer.
 EOTEXT
       );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function getRevisionID() {
     return $this->revisionID;
   }
 
   public function getArguments() {
     return array(
       'show' => array(
         'help' =>
           'Show the command which would be issued, but do not actually '.
           'commit anything.'
       ),
       'revision' => array(
         'param' => 'revision_id',
         'help' =>
           'Commit a specific revision. If you do not specify a revision, '.
           'arc will look for committable revisions.',
       )
     );
   }
 
   public function run() {
     $repository_api = $this->getRepositoryAPI();
 
     if (!($repository_api instanceof ArcanistSubversionAPI)) {
       throw new ArcanistUsageException(
         "'arc commit' is only supported under svn.");
     }
 
 
     $revision_id = $this->normalizeRevisionID($this->getArgument('revision'));
     if (!$revision_id) {
       $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
         $this->getConduit(),
         array(
           'authors' => array($this->getUserPHID()),
           'status'  => 'status-accepted',
         ));
 
       if (count($revisions) == 0) {
         throw new ArcanistUsageException(
           "Unable to identify the revision in the working copy. Use ".
           "'--revision <revision_id>' to select a revision.");
       } else if (count($revisions) > 1) {
         throw new ArcanistUsageException(
           "More than one revision exists in the working copy:\n\n".
           $this->renderRevisionList($revisions)."\n".
           "Use '--revision <revision_id>' to select a revision.");
       }
 
     } else {
       $revisions = $this->getConduit()->callMethodSynchronous(
         'differential.query',
         array(
           'ids' => array($revision_id),
         ));
 
       if (count($revisions) == 0) {
         throw new ArcanistUsageException(
           "Revision 'D{$revision_id}' does not exist.");
       }
     }
 
     $revision = head($revisions);
     $this->revisionID = $revision['id'];
     $revision_id = $revision['id'];
 
     $is_show = $this->getArgument('show');
 
     if (!$is_show) {
       $this->runSanityChecks($revision);
     }
 
     $message = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => $revision_id,
         'edit'        => false,
       ));
 
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_COMMIT_WILLCOMMITSVN,
       array(
         'message'   => $message,
       ));
 
     $message = $event->getValue('message');
 
     if ($is_show) {
       echo $message."\n";
       return 0;
     }
 
     $revision_title = $revision['title'];
     echo "Committing 'D{$revision_id}: {$revision_title}'...\n";
 
     $files = $this->getCommitFileList($revision);
 
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
 
     $command = csprintf(
       'svn commit %Ls --encoding utf-8 -F %s',
       $files,
       $tmp_file);
 
     // make sure to specify LANG on non-windows systems to suppress any fancy
     // warnings; see @{method:getSVNLangEnvVar}.
     if (!phutil_is_windows()) {
       $command = csprintf('LANG=%C %C', $this->getSVNLangEnvVar(), $command);
     }
 
     chdir($repository_api->getPath());
 
     $err = phutil_passthru('%C', $command);
     if ($err) {
       throw new Exception("Executing 'svn commit' failed!");
     }
 
     $mark_workflow = $this->buildChildWorkflow(
       'close-revision',
       array(
         '--finalize',
         $revision_id,
       ));
     $mark_workflow->run();
 
     return $err;
   }
 
   protected function getCommitFileList(array $revision) {
     $repository_api = $this->getRepositoryAPI();
     $revision_id = $revision['id'];
 
     $commit_paths = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitpaths',
       array(
         'revision_id' => $revision_id,
       ));
     $dir_paths = array();
     foreach ($commit_paths as $path) {
       $path = dirname($path);
       while ($path != '.') {
         $dir_paths[$path] = true;
         $path = dirname($path);
       }
     }
     $commit_paths = array_fill_keys($commit_paths, true);
 
     $status = $repository_api->getSVNStatus();
 
     $modified_but_not_included = array();
     foreach ($status as $path => $mask) {
       if (!empty($dir_paths[$path])) {
         $commit_paths[$path] = true;
       }
       if (!empty($commit_paths[$path])) {
         continue;
       }
       foreach ($commit_paths as $will_commit => $ignored) {
         if (Filesystem::isDescendant($path, $will_commit)) {
           throw new ArcanistUsageException(
             "This commit includes the directory '{$will_commit}', but ".
             "it contains a modified path ('{$path}') which is NOT included ".
             "in the commit. Subversion can not handle this operation and ".
             "will commit the path anyway. You need to sort out the working ".
             "copy changes to '{$path}' before you may proceed with the ".
             "commit.");
         }
       }
       $modified_but_not_included[] = $path;
     }
 
     if ($modified_but_not_included) {
       $prefix = pht(
         'Locally modified path(s) are not included in this revision:',
         count($modified_but_not_included));
       $prompt = pht(
         'They will NOT be committed. Commit this revision anyway?',
         count($modified_but_not_included));
       $this->promptFileWarning($prefix, $prompt, $modified_but_not_included);
     }
 
     $do_not_exist = array();
     foreach ($commit_paths as $path => $ignored) {
       $disk_path = $repository_api->getPath($path);
       if (file_exists($disk_path)) {
         continue;
       }
       if (is_link($disk_path)) {
         continue;
       }
       if (idx($status, $path) & ArcanistRepositoryAPI::FLAG_DELETED) {
         continue;
       }
       $do_not_exist[] = $path;
       unset($commit_paths[$path]);
     }
 
     if ($do_not_exist) {
       $prefix = pht(
         'Revision includes changes to path(s) that do not exist:',
         count($do_not_exist));
       $prompt = 'Commit this revision anyway?';
       $this->promptFileWarning($prefix, $prompt, $do_not_exist);
     }
 
     $files = array_keys($commit_paths);
     $files = ArcanistSubversionAPI::escapeFileNamesForSVN($files);
 
     if (empty($files)) {
       throw new ArcanistUsageException(
         'There is nothing left to commit. None of the modified paths exist.');
     }
 
     return $files;
   }
 
   protected function promptFileWarning($prefix, $prompt, array $paths) {
     echo $prefix."\n\n";
     foreach ($paths as $path) {
       echo "    ".$path."\n";
     }
     if (!phutil_console_confirm($prompt)) {
       throw new ArcanistUserAbortException();
     }
   }
 
   protected function getSupportedRevisionControlSystems() {
     return array('svn');
   }
 
   /**
    * On some systems, we need to specify "en_US.UTF-8" instead of "en_US.utf8",
    * and SVN spews some bewildering warnings if we don't:
    *
    *   svn: warning: cannot set LC_CTYPE locale
    *   svn: warning: environment variable LANG is en_US.utf8
    *   svn: warning: please check that your locale name is correct
    *
    * For example, it happens on epriestley's Mac (10.6.7) with
    * Subversion 1.6.15.
    */
   private function getSVNLangEnvVar() {
     $locale = 'en_US.utf8';
     try {
       list($locales) = execx('locale -a');
       $locales = explode("\n", trim($locales));
       $locales = array_fill_keys($locales, true);
       if (isset($locales['en_US.UTF-8'])) {
         $locale = 'en_US.UTF-8';
       }
     } catch (Exception $ex) {
       // Ignore.
     }
     return $locale;
   }
 
   private function runSanityChecks(array $revision) {
     $repository_api = $this->getRepositoryAPI();
     $revision_id = $revision['id'];
     $revision_title = $revision['title'];
 
     $confirm = array();
 
     if ($revision['status'] != ArcanistDifferentialRevisionStatus::ACCEPTED) {
       $confirm[] =
         "Revision 'D{$revision_id}: {$revision_title}' has not been accepted. ".
         "Commit this revision anyway?";
     }
 
     if ($revision['authorPHID'] != $this->getUserPHID()) {
       $confirm[] =
         "You are not the author of 'D{$revision_id}: {$revision_title}'. ".
         "Commit this revision anyway?";
     }
 
     $revision_source = idx($revision, 'branch');
     $current_source = $repository_api->getBranchName();
     if ($revision_source != $current_source) {
       $confirm[] =
         "Revision 'D{$revision_id}: {$revision_title}' was generated from ".
         "'{$revision_source}', but current working copy root is ".
         "'{$current_source}'. Commit this revision anyway?";
     }
 
     foreach ($confirm as $thing) {
       if (!phutil_console_confirm($thing)) {
         throw new ArcanistUserAbortException();
       }
     }
   }
 
-
 }
diff --git a/src/workflow/ArcanistCoverWorkflow.php b/src/workflow/ArcanistCoverWorkflow.php
index 385658e3..e36c8a90 100644
--- a/src/workflow/ArcanistCoverWorkflow.php
+++ b/src/workflow/ArcanistCoverWorkflow.php
@@ -1,172 +1,169 @@
 <?php
 
 /**
  * Covers your professional reputation by blaming changes to locate reviewers.
- *
- * @group workflow
  */
 final class ArcanistCoverWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'cover';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **cover** [--rev __revision__] [__path__ ...]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn, git, hg
           Cover your... professional reputation. Show blame for the lines you
           changed in your working copy (svn) or since some commit (hg, git).
           This will take a minute because blame takes a minute, especially under
           SVN.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'rev' => array(
         'param'     => 'revision',
         'help'      => 'Cover changes since a specific revision.',
         'supports'  => array(
           'git',
           'hg',
         ),
         'nosupport' => array(
           'svn' => 'cover does not currently support --rev in svn.',
         ),
       ),
       '*' => 'paths',
     );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresConduit() {
     return false;
   }
 
   public function requiresAuthentication() {
     return false;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function run() {
-
     $repository_api = $this->getRepositoryAPI();
 
     $in_paths = $this->getArgument('paths');
     $in_rev = $this->getArgument('rev');
 
     if ($in_rev) {
       $this->parseBaseCommitArgument(array($in_rev));
     }
 
     $paths = $this->selectPathsForWorkflow(
       $in_paths,
       $in_rev,
       ArcanistRepositoryAPI::FLAG_UNTRACKED |
       ArcanistRepositoryAPI::FLAG_ADDED);
 
     if (!$paths) {
       throw new ArcanistNoEffectException(
         "You're covered, you didn't change anything.");
     }
 
     $covers = array();
     foreach ($paths as $path) {
       if (is_dir($repository_api->getPath($path))) {
         continue;
       }
 
       $lines = $this->getChangedLines($path, 'cover');
       if (!$lines) {
         continue;
       }
 
       $blame = $repository_api->getBlame($path);
       foreach ($lines as $line) {
         list($author, $revision) = idx($blame, $line, array(null, null));
         if (!$author) {
           continue;
         }
         if (!isset($covers[$author])) {
           $covers[$author] = array();
         }
         if (!isset($covers[$author][$path])) {
           $covers[$author][$path] = array(
             'lines'     => array(),
             'revisions' => array(),
           );
         }
         $covers[$author][$path]['lines'][] = $line;
         $covers[$author][$path]['revisions'][] = $revision;
       }
     }
 
     if (count($covers)) {
       foreach ($covers as $author => $files) {
         echo phutil_console_format(
           "**%s**\n",
           $author);
         foreach ($files as $file => $info) {
           $line_noun = pht('line(s)', count($info['lines']));
           $lines = $this->readableSequenceFromLineNumbers($info['lines']);
           echo "  {$file}: {$line_noun} {$lines}\n";
         }
       }
     } else {
       echo "You're covered, your changes didn't touch anyone else's code.\n";
     }
 
     return 0;
   }
 
   private function readableSequenceFromLineNumbers(array $array) {
     $sequence = array();
     $last = null;
     $seq  = null;
     $array = array_unique(array_map('intval', $array));
     sort($array);
     foreach ($array as $element) {
       if ($seq !== null && $element == ($seq + 1)) {
         $seq++;
         continue;
       }
 
       if ($seq === null) {
         $last = $element;
         $seq  = $element;
         continue;
       }
 
       if ($seq > $last) {
         $sequence[] = $last.'-'.$seq;
       } else {
         $sequence[] = $last;
       }
 
       $last = $element;
       $seq  = $element;
     }
     if ($last !== null && $seq > $last) {
       $sequence[] = $last.'-'.$seq;
     } else if ($last !== null) {
       $sequence[] = $element;
     }
 
     return implode(', ', $sequence);
   }
 
 }
diff --git a/src/workflow/ArcanistDiffWorkflow.php b/src/workflow/ArcanistDiffWorkflow.php
index a539bab2..9bea0d93 100644
--- a/src/workflow/ArcanistDiffWorkflow.php
+++ b/src/workflow/ArcanistDiffWorkflow.php
@@ -1,2628 +1,2626 @@
 <?php
 
 /**
  * Sends changes from your working copy to Differential for code review.
  *
  * @task lintunit   Lint and Unit Tests
  * @task message    Commit and Update Messages
  * @task diffspec   Diff Specification
  * @task diffprop   Diff Properties
- *
- * @group workflow
  */
 final class ArcanistDiffWorkflow extends ArcanistBaseWorkflow {
 
   private $console;
   private $hasWarnedExternals = false;
   private $unresolvedLint;
   private $excuses = array('lint' => null, 'unit' => null);
   private $testResults;
   private $diffID;
   private $revisionID;
   private $postponedLinters;
   private $haveUncommittedChanges = false;
   private $diffPropertyFutures = array();
   private $commitMessageFromRevision;
 
   public function getWorkflowName() {
     return 'diff';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **diff** [__paths__] (svn)
       **diff** [__commit__] (git, hg)
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Generate a Differential diff or revision from local changes.
 
           Under git and mercurial, you can specify a commit (like __HEAD^^^__
           or __master__) and Differential will generate a diff against the
           merge base of that commit and your current working directory parent.
 
           Under svn, you can choose to include only some of the modified files
           in the working copy in the diff by specifying their paths. If you
           omit paths, all changes are included in the diff.
 EOTEXT
       );
   }
 
   public function requiresWorkingCopy() {
     return !$this->isRawDiffSource();
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     if (!$this->isRawDiffSource()) {
       return true;
     }
 
     if ($this->getArgument('use-commit-message')) {
       return true;
     }
 
     return false;
   }
 
   public function getDiffID() {
     return $this->diffID;
   }
 
   public function getArguments() {
     $arguments = array(
       'message' => array(
         'short'       => 'm',
         'param'       => 'message',
         'help' =>
           'When updating a revision, use the specified message instead of '.
           'prompting.',
       ),
       'message-file' => array(
         'short' => 'F',
         'param' => 'file',
         'paramtype' => 'file',
         'help' => 'When creating a revision, read revision information '.
                   'from this file.',
       ),
       'use-commit-message' => array(
         'supports' => array(
           'git',
           // TODO: Support mercurial.
         ),
         'short' => 'C',
         'param' => 'commit',
         'help' => 'Read revision information from a specific commit.',
         'conflicts' => array(
           'only'    => null,
           'preview' => null,
           'update'  => null,
         ),
       ),
       'edit' => array(
         'supports'    => array(
           'git',
           'hg',
         ),
         'nosupport'   => array(
           'svn' => 'Edit revisions via the web interface when using SVN.',
         ),
         'help' =>
           'When updating a revision under git, edit revision information '.
           'before updating.',
       ),
       'raw' => array(
         'help' =>
           'Read diff from stdin, not from the working copy. This disables '.
           'many Arcanist/Phabricator features which depend on having access '.
           'to the working copy.',
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => '--raw disables lint.',
           'never-apply-patches' => '--raw disables lint.',
           'advice'              => '--raw disables lint.',
           'lintall'             => '--raw disables lint.',
 
           'create'              => '--raw and --create both need stdin. '.
                                    'Use --raw-command.',
           'edit'                => '--raw and --edit both need stdin. '.
                                    'Use --raw-command.',
           'raw-command'         => null,
         ),
       ),
       'raw-command' => array(
         'param' => 'command',
         'help' =>
           'Generate diff by executing a specified command, not from the '.
           'working copy. This disables many Arcanist/Phabricator features '.
           'which depend on having access to the working copy.',
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => '--raw-command disables lint.',
           'never-apply-patches' => '--raw-command disables lint.',
           'advice'              => '--raw-command disables lint.',
           'lintall'             => '--raw-command disables lint.',
         ),
       ),
       'create' => array(
         'help' => 'Always create a new revision.',
         'conflicts' => array(
           'edit'    => '--create can not be used with --edit.',
           'only'    => '--create can not be used with --only.',
           'preview' => '--create can not be used with --preview.',
           'update'  => '--create can not be used with --update.',
         ),
       ),
       'update' => array(
         'param' => 'revision_id',
         'help'  => 'Always update a specific revision.',
       ),
       'nounit' => array(
         'help' =>
           'Do not run unit tests.',
       ),
       'nolint' => array(
         'help' =>
           'Do not run lint.',
         'conflicts' => array(
           'lintall'   => '--nolint suppresses lint.',
           'advice'    => '--nolint suppresses lint.',
           'apply-patches' => '--nolint suppresses lint.',
           'never-apply-patches' => '--nolint suppresses lint.',
         ),
       ),
       'only' => array(
         'help' =>
           'Only generate a diff, without running lint, unit tests, or other '.
           'auxiliary steps. See also --preview.',
         'conflicts' => array(
           'preview'   => null,
           'message'   => '--only does not affect revisions.',
           'edit'      => '--only does not affect revisions.',
           'lintall'   => '--only suppresses lint.',
           'advice'    => '--only suppresses lint.',
           'apply-patches' => '--only suppresses lint.',
           'never-apply-patches' => '--only suppresses lint.',
         ),
       ),
       'preview' => array(
         'help' =>
           'Instead of creating or updating a revision, only create a diff, '.
           'which you may later attach to a revision. This still runs lint '.
           'unit tests. See also --only.',
         'conflicts' => array(
           'only'      => null,
           'edit'      => '--preview does affect revisions.',
           'message'   => '--preview does not update any revision.',
         ),
       ),
       'plan-changes' => array(
         'help' =>
           'Create or update a revision without requesting a code review.',
         'conflicts' => array(
           'only'     => '--only does not affect revisions.',
           'preview'  => '--preview does not affect revisions.',
         ),
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           'Attempt to convert non UTF-8 hunks into specified encoding.',
       ),
       'allow-untracked' => array(
         'help' =>
           'Skip checks for untracked files in the working copy.',
       ),
       'excuse' => array(
         'param' => 'excuse',
         'help' => 'Provide a prepared in advance excuse for any lints/tests'.
           ' shall they fail.',
       ),
       'less-context' => array(
         'help' =>
           "Normally, files are diffed with full context: the entire file is ".
           "sent to Differential so reviewers can 'show more' and see it. If ".
           "you are making changes to very large files with tens of thousands ".
           "of lines, this may not work well. With this flag, a diff will ".
           "be created that has only a few lines of context.",
       ),
       'lintall' => array(
         'help' =>
           'Raise all lint warnings, not just those on lines you changed.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'advice' => array(
         'help' =>
           'Require excuse for lint advice in addition to lint warnings and '.
           'errors.',
       ),
       'only-new' => array(
         'param' => 'bool',
         'help' =>
           'Display only lint messages not present in the original code.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'apply-patches' => array(
         'help' =>
           'Apply patches suggested by lint to the working copy without '.
           'prompting.',
         'conflicts' => array(
           'never-apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'never-apply-patches' => array(
         'help' => 'Never apply patches suggested by lint.',
         'conflicts' => array(
           'apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-all' => array(
         'help' =>
           'When linting git repositories, amend HEAD with all patches '.
           'suggested by lint without prompting.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-autofixes' => array(
         'help' =>
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'add-all' => array(
         'short' => 'a',
         'help' =>
           'Automatically add all untracked, unstaged and uncommitted files to '.
           'the commit.',
       ),
       'json' => array(
         'help' =>
           'Emit machine-readable JSON. EXPERIMENTAL! Probably does not work!',
       ),
       'no-amend' => array(
         'help' => 'Never amend commits in the working copy with lint patches.',
       ),
       'uncommitted' => array(
         'help' => 'Suppress warning about uncommitted changes.',
         'supports' => array(
           'hg',
         ),
       ),
       'verbatim' => array(
         'help' => 'When creating a revision, try to use the working copy '.
                   'commit message verbatim, without prompting to edit it. '.
                   'When updating a revision, update some fields from the '.
                   'local commit message.',
         'supports' => array(
           'hg',
           'git',
         ),
         'conflicts' => array(
           'use-commit-message'  => true,
           'update'              => true,
           'only'                => true,
           'preview'             => true,
           'raw'                 => true,
           'raw-command'         => true,
           'message-file'        => true,
         ),
       ),
       'reviewers' => array(
         'param' => 'usernames',
         'help' => 'When creating a revision, add reviewers.',
         'conflicts' => array(
           'only'    => true,
           'preview' => true,
           'update'  => true,
         ),
       ),
       'cc' => array(
         'param' => 'usernames',
         'help' => 'When creating a revision, add CCs.',
         'conflicts' => array(
           'only'    => true,
           'preview' => true,
           'update'  => true,
         ),
       ),
       'skip-binaries' => array(
         'help'  => 'Do not upload binaries (like images).',
       ),
       'ignore-unsound-tests' => array(
         'help'  => 'Ignore unsound test failures without prompting.',
       ),
       'base' => array(
         'param' => 'rules',
         'help'  => 'Additional rules for determining base revision.',
         'nosupport' => array(
           'svn' => 'Subversion does not use base commits.',
         ),
         'supports' => array('git', 'hg'),
       ),
       'no-diff' => array(
         'help' => 'Only run lint and unit tests. Intended for internal use.',
       ),
       'background' => array(
         'param' => 'bool',
         'help' =>
           'Run lint and unit tests on background. '.
           '"0" to disable, "1" to enable (default).',
       ),
       'cache' => array(
         'param' => 'bool',
         'help' => '0 to disable lint cache, 1 to enable (default).',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'coverage' => array(
         'help' => 'Always enable coverage information.',
         'conflicts' => array(
           'no-coverage' => null,
         ),
         'passthru' => array(
           'unit' => true,
         ),
       ),
       'no-coverage' => array(
         'help' => 'Always disable coverage information.',
         'passthru' => array(
           'unit' => true,
         ),
       ),
       '*' => 'paths',
       'head' => array(
         'param' => 'commit',
         'help' => pht(
           'Specify the end of the commit range. This disables many '.
           'Arcanist/Phabricator features which depend on having access to '.
           'the working copy.'),
         'supports' => array('git'),
         'nosupport' => array(
           'svn' => pht('Subversion does not support commit ranges.'),
           'hg' => pht('Mercurial does not support --head yet.'),
         ),
         'conflicts' => array(
           'lintall'   => '--head suppresses lint.',
           'advice'    => '--head suppresses lint.',
         ),
       )
     );
 
     if (phutil_is_windows()) {
       unset($arguments['background']);
     }
 
     return $arguments;
   }
 
   public function isRawDiffSource() {
     return $this->getArgument('raw') || $this->getArgument('raw-command');
   }
 
   public function run() {
     $this->console = PhutilConsole::getConsole();
 
     $this->runRepositoryAPISetup();
 
     if ($this->getArgument('no-diff')) {
       $this->removeScratchFile('diff-result.json');
       $data = $this->runLintUnit();
       $this->writeScratchJSONFile('diff-result.json', $data);
       return 0;
     }
 
     $this->runDiffSetupBasics();
 
     $background = $this->getArgument('background', true);
     if ($this->isRawDiffSource() || phutil_is_windows()) {
       $background = false;
     }
 
     if ($background) {
       $argv = $this->getPassedArguments();
       if (!PhutilConsoleFormatter::getDisableANSI()) {
         array_unshift($argv, '--ansi');
       }
 
       $repo = $this->getRepositoryAPI();
       $head_commit = $this->getArgument('head');
       if ($head_commit !== null) {
         $repo->setHeadCommit($head_commit);
       }
 
       if ($repo->supportsCommitRanges()) {
         $repo->getBaseCommit();
       }
 
       $script = phutil_get_library_root('arcanist').'/../scripts/arcanist.php';
       if ($argv) {
         $lint_unit = new ExecFuture(
           'php %s --recon diff --no-diff %Ls',
           $script,
           $argv);
       } else {
         $lint_unit = new ExecFuture(
           'php %s --recon diff --no-diff',
           $script);
       }
 
       $lint_unit->write('', true);
       $lint_unit->start();
     }
 
     $commit_message = $this->buildCommitMessage();
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDBUILDMESSAGE,
       array(
         'message' => $commit_message,
       ));
 
     if (!$this->shouldOnlyCreateDiff()) {
       $revision = $this->buildRevisionFromCommitMessage($commit_message);
     }
 
     if ($background) {
       $server = new PhutilConsoleServer();
       $server->addExecFutureClient($lint_unit);
       $server->setHandler(array($this, 'handleServerMessage'));
       $server->run();
 
       list($err) = $lint_unit->resolve();
       $data = $this->readScratchJSONFile('diff-result.json');
       if ($err || !$data) {
         throw new Exception(
           'Unable to read results from background linting and unit testing. '.
           'You can try running arc diff again with --background 0');
       }
     } else {
       $server = $this->console->getServer();
       $server->setHandler(array($this, 'handleServerMessage'));
       $data = $this->runLintUnit();
     }
     $lint_result = $data['lintResult'];
     $this->unresolvedLint = $data['unresolvedLint'];
     $this->postponedLinters = $data['postponedLinters'];
     $unit_result = $data['unitResult'];
     $this->testResults = $data['testResults'];
 
     if ($this->getArgument('nolint')) {
       $this->excuses['lint'] = $this->getSkipExcuse(
         'Provide explanation for skipping lint or press Enter to abort:',
         'lint-excuses');
     }
 
     if ($this->getArgument('nounit')) {
       $this->excuses['unit'] = $this->getSkipExcuse(
         'Provide explanation for skipping unit tests or press Enter to abort:',
         'unit-excuses');
     }
 
     $changes = $this->generateChanges();
     if (!$changes) {
       throw new ArcanistUsageException(
         'There are no changes to generate a diff from!');
     }
 
     $diff_spec = array(
       'changes' => mpull($changes, 'toDictionary'),
       'lintStatus' => $this->getLintStatus($lint_result),
       'unitStatus' => $this->getUnitStatus($unit_result),
     ) + $this->buildDiffSpecification();
 
     $conduit = $this->getConduit();
     $diff_info = $conduit->callMethodSynchronous(
       'differential.creatediff',
       $diff_spec);
 
     $this->diffID = $diff_info['diffid'];
 
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_WASCREATED,
       array(
         'diffID' => $diff_info['diffid'],
         'lintResult' => $lint_result,
         'unitResult' => $unit_result,
       ));
 
     $this->updateLintDiffProperty();
     $this->updateUnitDiffProperty();
     $this->updateLocalDiffProperty();
     $this->resolveDiffPropertyUpdates();
 
     $output_json = $this->getArgument('json');
 
     if ($this->shouldOnlyCreateDiff()) {
       if (!$output_json) {
         echo phutil_console_format(
           "Created a new Differential diff:\n".
           "        **Diff URI:** __%s__\n\n",
           $diff_info['uri']);
       } else {
         $human = ob_get_clean();
         echo json_encode(array(
           'diffURI' => $diff_info['uri'],
           'diffID'  => $this->getDiffID(),
           'human'   => $human,
         ))."\n";
         ob_start();
       }
     } else {
       $revision['diffid'] = $this->getDiffID();
 
       if ($commit_message->getRevisionID()) {
         $result = $conduit->callMethodSynchronous(
           'differential.updaterevision',
           $revision);
 
         foreach (array('edit-messages.json', 'update-messages.json') as $file) {
           $messages = $this->readScratchJSONFile($file);
           unset($messages[$revision['id']]);
           $this->writeScratchJSONFile($file, $messages);
         }
 
         echo "Updated an existing Differential revision:\n";
       } else {
         $revision = $this->dispatchWillCreateRevisionEvent($revision);
 
         $result = $conduit->callMethodSynchronous(
           'differential.createrevision',
           $revision);
 
         $revised_message = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => $result['revisionid'],
           ));
 
         if ($this->shouldAmend()) {
           $repository_api = $this->getRepositoryAPI();
           if ($repository_api->supportsAmend()) {
             echo "Updating commit message...\n";
             $repository_api->amendCommit($revised_message);
           } else {
             echo 'Commit message was not amended. Amending commit message is '.
                  'only supported in git and hg (version 2.2 or newer)';
           }
         }
 
         echo "Created a new Differential revision:\n";
       }
 
       $uri = $result['uri'];
       echo phutil_console_format(
         "        **Revision URI:** __%s__\n\n",
         $uri);
 
       if ($this->getArgument('plan-changes')) {
         $conduit->callMethodSynchronous(
           'differential.createcomment',
           array(
             'revision_id' => $result['revisionid'],
             'action' => 'rethink',
           ));
         echo "Planned changes to the revision.\n";
       }
     }
 
     echo "Included changes:\n";
     foreach ($changes as $change) {
       echo '  '.$change->renderTextSummary()."\n";
     }
 
     if ($output_json) {
       ob_get_clean();
     }
 
     $this->removeScratchFile('create-message');
 
     return 0;
   }
 
   private function runRepositoryAPISetup() {
     if (!$this->requiresRepositoryAPI()) {
       return;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($this->getArgument('less-context')) {
       $repository_api->setDiffLinesOfContext(3);
     }
 
     $repository_api->setBaseCommitArgumentRules(
       $this->getArgument('base', ''));
 
     if ($repository_api->supportsCommitRanges()) {
       $this->parseBaseCommitArgument($this->getArgument('paths'));
     }
   }
 
   private function runDiffSetupBasics() {
     $output_json = $this->getArgument('json');
     if ($output_json) {
       // TODO: We should move this to a higher-level and put an indirection
       // layer between echoing stuff and stdout.
       ob_start();
     }
 
     if ($this->requiresWorkingCopy()) {
       $repository_api = $this->getRepositoryAPI();
       try {
         if ($this->getArgument('add-all')) {
           $this->setCommitMode(self::COMMIT_ENABLE);
         } else if ($this->getArgument('uncommitted')) {
           $this->setCommitMode(self::COMMIT_DISABLE);
         } else {
           $this->setCommitMode(self::COMMIT_ALLOW);
         }
         if ($repository_api instanceof ArcanistSubversionAPI) {
           $repository_api->limitStatusToPaths($this->getArgument('paths'));
         }
         if (!$this->getArgument('head')) {
           $this->requireCleanWorkingCopy();
         }
       } catch (ArcanistUncommittedChangesException $ex) {
         if ($repository_api instanceof ArcanistMercurialAPI) {
           $use_dirty_changes = false;
           if ($this->getArgument('uncommitted')) {
             // OK.
           } else {
             $ok = phutil_console_confirm(
               "You have uncommitted changes in your working copy. You can ".
               "include them in the diff, or abort and deal with them. (Use ".
               "'--uncommitted' to include them and skip this prompt.) ".
               "Do you want to include uncommitted changes in the diff?");
             if (!$ok) {
               throw $ex;
             }
           }
 
           $this->haveUncommittedChanges = true;
         } else {
           throw $ex;
         }
       }
     }
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDCOLLECTCHANGES,
       array());
   }
 
   private function buildRevisionFromCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
 
     $conduit = $this->getConduit();
 
     $revision_id = $message->getRevisionID();
     $revision = array(
       'fields' => $message->getFields(),
     );
 
     if ($revision_id) {
 
       // With '--verbatim', pass the (possibly modified) local fields. This
       // allows the user to edit some fields (like "title" and "summary")
       // locally without '--edit' and have changes automatically synchronized.
       // Without '--verbatim', we do not update the revision to reflect local
       // commit message changes.
       if ($this->getArgument('verbatim')) {
         $use_fields = $message->getFields();
       } else {
         $use_fields = array();
       }
 
       $should_edit = $this->getArgument('edit');
       $edit_messages = $this->readScratchJSONFile('edit-messages.json');
       $remote_corpus = idx($edit_messages, $revision_id);
 
       if (!$should_edit || !$remote_corpus || $use_fields) {
         if ($this->commitMessageFromRevision) {
           $remote_corpus = $this->commitMessageFromRevision;
         } else {
           $remote_corpus = $conduit->callMethodSynchronous(
             'differential.getcommitmessage',
             array(
               'revision_id' => $revision_id,
               'edit'        => 'edit',
               'fields'      => $use_fields,
             ));
         }
       }
 
       if ($should_edit) {
         $edited = $this->newInteractiveEditor($remote_corpus)
           ->setName('differential-edit-revision-info')
           ->editInteractively();
         if ($edited != $remote_corpus) {
           $remote_corpus = $edited;
           $edit_messages[$revision_id] = $remote_corpus;
           $this->writeScratchJSONFile('edit-messages.json', $edit_messages);
         }
       }
 
       if ($this->commitMessageFromRevision == $remote_corpus) {
         $new_message = $message;
       } else {
         $remote_corpus = ArcanistCommentRemover::removeComments(
           $remote_corpus);
         $new_message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $remote_corpus);
         $new_message->pullDataFromConduit($conduit);
       }
 
       $revision['fields'] = $new_message->getFields();
 
       $revision['id'] = $revision_id;
       $this->revisionID = $revision_id;
 
       $revision['message'] = $this->getArgument('message');
       if (!strlen($revision['message'])) {
         $update_messages = $this->readScratchJSONFile('update-messages.json');
 
         $update_messages[$revision_id] = $this->getUpdateMessage(
           $revision['fields'],
           idx($update_messages, $revision_id));
 
         $revision['message'] = ArcanistCommentRemover::removeComments(
           $update_messages[$revision_id]);
         if (!strlen(trim($revision['message']))) {
           throw new ArcanistUserAbortException();
         }
 
         $this->writeScratchJSONFile('update-messages.json', $update_messages);
       }
     }
 
     return $revision;
   }
 
   protected function shouldOnlyCreateDiff() {
 
     if ($this->getArgument('create')) {
       return false;
     }
 
     if ($this->getArgument('update')) {
       return false;
     }
 
     if ($this->getArgument('use-commit-message')) {
       return false;
     }
 
     if ($this->isRawDiffSource()) {
       return true;
     }
 
     return $this->getArgument('preview') ||
            $this->getArgument('only');
   }
 
   private function generateAffectedPaths() {
     if ($this->isRawDiffSource()) {
       return array();
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $file_list = new FileList($this->getArgument('paths', array()));
       $paths = $repository_api->getSVNStatus($externals = true);
       foreach ($paths as $path => $mask) {
         if (!$file_list->contains($repository_api->getPath($path), true)) {
           unset($paths[$path]);
         }
       }
 
       $warn_externals = array();
       foreach ($paths as $path => $mask) {
         $any_mod = ($mask & ArcanistRepositoryAPI::FLAG_ADDED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_MODIFIED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_DELETED);
         if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
           unset($paths[$path]);
           if ($any_mod) {
             $warn_externals[] = $path;
           }
         }
       }
 
       if ($warn_externals && !$this->hasWarnedExternals) {
         echo phutil_console_format(
           "The working copy includes changes to 'svn:externals' paths. These ".
           "changes will not be included in the diff because SVN can not ".
           "commit 'svn:externals' changes alongside normal changes.".
           "\n\n".
           "Modified 'svn:externals' files:".
           "\n\n".
           phutil_console_wrap(implode("\n", $warn_externals), 8));
         $prompt = 'Generate a diff (with just local changes) anyway?';
         if (!phutil_console_confirm($prompt)) {
           throw new ArcanistUserAbortException();
         } else {
           $this->hasWarnedExternals = true;
         }
       }
 
     } else {
       $paths = $repository_api->getWorkingCopyStatus();
     }
 
     foreach ($paths as $path => $mask) {
       if ($mask & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
         unset($paths[$path]);
       }
     }
 
     return $paths;
   }
 
 
   protected function generateChanges() {
     $parser = $this->newDiffParser();
 
     $is_raw = $this->isRawDiffSource();
     if ($is_raw) {
 
       if ($this->getArgument('raw')) {
         fwrite(STDERR, "Reading diff from stdin...\n");
         $raw_diff = file_get_contents('php://stdin');
       } else if ($this->getArgument('raw-command')) {
         list($raw_diff) = execx('%C', $this->getArgument('raw-command'));
       } else {
         throw new Exception('Unknown raw diff source.');
       }
 
       $changes = $parser->parseDiff($raw_diff);
       foreach ($changes as $key => $change) {
         // Remove "message" changes, e.g. from "git show".
         if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
           unset($changes[$key]);
         }
       }
       return $changes;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $paths = $this->generateAffectedPaths();
       $this->primeSubversionWorkingCopyData($paths);
 
       // Check to make sure the user is diffing from a consistent base revision.
       // This is mostly just an abuse sanity check because it's silly to do this
       // and makes the code more difficult to effectively review, but it also
       // affects patches and makes them nonportable.
       $bases = $repository_api->getSVNBaseRevisions();
 
       // Remove all files with baserev "0"; these files are new.
       foreach ($bases as $path => $baserev) {
         if ($bases[$path] <= 0) {
           unset($bases[$path]);
         }
       }
 
       if ($bases) {
         $rev = reset($bases);
 
         $revlist = array();
         foreach ($bases as $path => $baserev) {
           $revlist[] = "    Revision {$baserev}, {$path}";
         }
         $revlist = implode("\n", $revlist);
 
         foreach ($bases as $path => $baserev) {
           if ($baserev !== $rev) {
             throw new ArcanistUsageException(
               "Base revisions of changed paths are mismatched. Update all ".
               "paths to the same base revision before creating a diff: ".
               "\n\n".
               $revlist);
           }
         }
 
         // If you have a change which affects several files, all of which are
         // at a consistent base revision, treat that revision as the effective
         // base revision. The use case here is that you made a change to some
         // file, which updates it to HEAD, but want to be able to change it
         // again without updating the entire working copy. This is a little
         // sketchy but it arises in Facebook Ops workflows with config files and
         // doesn't have any real material tradeoffs (e.g., these patches are
         // perfectly applyable).
         $repository_api->overrideSVNBaseRevisionNumber($rev);
       }
 
       $changes = $parser->parseSubversionDiff(
         $repository_api,
         $paths);
     } else if ($repository_api instanceof ArcanistGitAPI) {
       $diff = $repository_api->getFullGitDiff(
         $repository_api->getBaseCommit(),
         $repository_api->getHeadCommit());
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           'No changes found. (Did you specify the wrong commit range?)');
       }
       $changes = $parser->parseDiff($diff);
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $diff = $repository_api->getFullMercurialDiff();
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           'No changes found. (Did you specify the wrong commit range?)');
       }
       $changes = $parser->parseDiff($diff);
     } else {
       throw new Exception('Repository API is not supported.');
     }
 
     if (count($changes) > 250) {
       $count = number_format(count($changes));
       $link =
         'http://www.phabricator.com/docs/phabricator/article/'.
         'Differential_User_Guide_Large_Changes.html';
       $message =
         "This diff has a very large number of changes ({$count}). ".
         "Differential works best for changes which will receive detailed ".
         "human review, and not as well for large automated changes or ".
         "bulk checkins. See {$link} for information about reviewing big ".
         "checkins. Continue anyway?";
       if (!phutil_console_confirm($message)) {
         throw new ArcanistUsageException(
           'Aborted generation of gigantic diff.');
       }
     }
 
     $limit = 1024 * 1024 * 4;
     foreach ($changes as $change) {
       $size = 0;
       foreach ($change->getHunks() as $hunk) {
         $size += strlen($hunk->getCorpus());
       }
       if ($size > $limit) {
         $file_name = $change->getCurrentPath();
         $change_size = number_format($size);
         $byte_warning =
           "Diff for '{$file_name}' with context is {$change_size} bytes in ".
           "length. Generally, source changes should not be this large.";
         if (!$this->getArgument('less-context')) {
           $byte_warning .=
             " If this file is a huge text file, try using the ".
             "'--less-context' flag.";
         }
         if ($repository_api instanceof ArcanistSubversionAPI) {
           throw new ArcanistUsageException(
             "{$byte_warning} If the file is not a text file, mark it as ".
             "binary with:".
             "\n\n".
             "  $ svn propset svn:mime-type application/octet-stream <filename>".
             "\n");
         } else {
           $confirm =
             "{$byte_warning} If the file is not a text file, you can ".
             "mark it 'binary'. Mark this file as 'binary' and continue?";
           if (phutil_console_confirm($confirm)) {
             $change->convertToBinaryChange($repository_api);
           } else {
             throw new ArcanistUsageException(
               'Aborted generation of gigantic diff.');
           }
         }
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
 
     $utf8_problems = array();
     foreach ($changes as $change) {
       foreach ($change->getHunks() as $hunk) {
         $corpus = $hunk->getCorpus();
         if (!phutil_is_utf8($corpus)) {
 
           // If this corpus is heuristically binary, don't try to convert it.
           // mb_check_encoding() and mb_convert_encoding() are both very very
           // liberal about what they're willing to process.
           $is_binary = ArcanistDiffUtils::isHeuristicBinaryFile($corpus);
           if (!$is_binary) {
 
             if (!$try_encoding) {
               try {
                 $try_encoding = $this->getRepositoryEncoding();
               } catch (ConduitClientException $e) {
                 if ($e->getErrorCode() == 'ERR-BAD-ARCANIST-PROJECT') {
                   echo phutil_console_wrap(
                     "Lookup of encoding in arcanist project failed\n".
                     $e->getMessage());
                 } else {
                   throw $e;
                 }
               }
             }
 
             if ($try_encoding) {
               $corpus = phutil_utf8_convert($corpus, 'UTF-8', $try_encoding);
               $name = $change->getCurrentPath();
               if (phutil_is_utf8($corpus)) {
                 $this->writeStatusMessage(
                   "Converted a '{$name}' hunk from '{$try_encoding}' ".
                   "to UTF-8.\n");
                 $hunk->setCorpus($corpus);
                 continue;
               }
             }
           }
           $utf8_problems[] = $change;
           break;
         }
       }
     }
 
     // If there are non-binary files which aren't valid UTF-8, warn the user
     // and treat them as binary changes. See D327 for discussion of why Arcanist
     // has this behavior.
     if ($utf8_problems) {
       $utf8_warning =
         pht(
           'This diff includes file(s) which are not valid UTF-8 (they contain '.
             'invalid byte sequences). You can either stop this workflow and '.
             'fix these files, or continue. If you continue, these files will '.
             'be marked as binary.',
           count($utf8_problems))."\n\n".
         "You can learn more about how Phabricator handles character encodings ".
         "(and how to configure encoding settings and detect and correct ".
         "encoding problems) by reading 'User Guide: UTF-8 and Character ".
         "Encoding' in the Phabricator documentation.\n\n".
         "    ".pht('AFFECTED FILE(S)', count($utf8_problems))."\n";
       $confirm = pht(
         'Do you want to mark these files as binary and continue?',
         count($utf8_problems));
 
       echo phutil_console_format("**Invalid Content Encoding (Non-UTF8)**\n");
       echo phutil_console_wrap($utf8_warning);
 
       $file_list = mpull($utf8_problems, 'getCurrentPath');
       $file_list = '    '.implode("\n    ", $file_list);
       echo $file_list;
 
       if (!phutil_console_confirm($confirm, $default_no = false)) {
         throw new ArcanistUsageException('Aborted workflow to fix UTF-8.');
       } else {
         foreach ($utf8_problems as $change) {
           $change->convertToBinaryChange($repository_api);
         }
       }
     }
 
     $this->uploadFilesForChanges($changes);
 
     return $changes;
   }
 
   private function getGitParentLogInfo() {
     $info = array(
       'parent'        => null,
       'base_revision' => null,
       'base_path'     => null,
       'uuid'          => null,
     );
 
     $repository_api = $this->getRepositoryAPI();
 
     $parser = $this->newDiffParser();
     $history_messages = $repository_api->getGitHistoryLog();
     if (!$history_messages) {
       // This can occur on the initial commit.
       return $info;
     }
     $history_messages = $parser->parseDiff($history_messages);
 
     foreach ($history_messages as $key => $change) {
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $change->getMetadata('message'));
         if ($message->getRevisionID() && $info['parent'] === null) {
           $info['parent'] = $message->getRevisionID();
         }
         if ($message->getGitSVNBaseRevision() &&
             $info['base_revision'] === null) {
           $info['base_revision'] = $message->getGitSVNBaseRevision();
           $info['base_path']     = $message->getGitSVNBasePath();
         }
         if ($message->getGitSVNUUID()) {
           $info['uuid'] = $message->getGitSVNUUID();
         }
         if ($info['parent'] && $info['base_revision']) {
           break;
         }
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         // Ignore.
       } catch (ArcanistUsageException $ex) {
         // Ignore an invalid Differential Revision field in the parent commit
       }
     }
 
     return $info;
   }
 
   protected function primeSubversionWorkingCopyData($paths) {
     $repository_api = $this->getRepositoryAPI();
 
     $futures = array();
     $targets = array();
     foreach ($paths as $path => $mask) {
       $futures[] = $repository_api->buildDiffFuture($path);
       $targets[] = array('command' => 'diff', 'path' => $path);
       $futures[] = $repository_api->buildInfoFuture($path);
       $targets[] = array('command' => 'info', 'path' => $path);
     }
 
     foreach (Futures($futures)->limit(8) as $key => $future) {
       $target = $targets[$key];
       if ($target['command'] == 'diff') {
         $repository_api->primeSVNDiffResult(
           $target['path'],
           $future->resolve());
       } else {
         $repository_api->primeSVNInfoResult(
           $target['path'],
           $future->resolve());
       }
     }
   }
 
   private function shouldAmend() {
     if ($this->isRawDiffSource()) {
       return false;
     }
 
     if ($this->haveUncommittedChanges) {
       return false;
     }
 
     if ($this->getArgument('no-amend')) {
       return false;
     }
 
     if ($this->getArgument('head') !== null) {
       return false;
     }
 
     // Run this last: with --raw or --raw-command, we won't have a repository
     // API.
     if ($this->isHistoryImmutable()) {
       return false;
     }
 
     return true;
   }
 
 
 /* -(  Lint and Unit Tests  )------------------------------------------------ */
 
 
   /**
    * @task lintunit
    */
   private function runLintUnit() {
     $lint_result = $this->runLint();
     $unit_result = $this->runUnit();
     return array(
       'lintResult' => $lint_result,
       'unresolvedLint' => $this->unresolvedLint,
       'postponedLinters' => $this->postponedLinters,
       'unitResult' => $unit_result,
       'testResults' => $this->testResults,
     );
   }
 
 
   /**
    * @task lintunit
    */
   private function runLint() {
     if ($this->getArgument('nolint') ||
         $this->getArgument('only') ||
         $this->isRawDiffSource() ||
         $this->getArgument('head')) {
       return ArcanistLintWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("Linting...\n");
     try {
       $argv = $this->getPassthruArgumentsAsArgv('lint');
       if ($repository_api->supportsCommitRanges()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getBaseCommit();
       }
 
       $lint_workflow = $this->buildChildWorkflow('lint', $argv);
 
       if ($this->shouldAmend()) {
         // TODO: We should offer to create a checkpoint commit.
         $lint_workflow->setShouldAmendChanges(true);
       }
 
       $lint_result = $lint_workflow->run();
 
       switch ($lint_result) {
         case ArcanistLintWorkflow::RESULT_OKAY:
           if ($this->getArgument('advice') &&
               $lint_workflow->getUnresolvedMessages()) {
             $this->getErrorExcuse(
               'lint',
               'Lint issued unresolved advice.',
               'lint-excuses');
           } else {
             $this->console->writeOut(
               "<bg:green>** LINT OKAY **</bg> No lint problems.\n");
           }
           break;
         case ArcanistLintWorkflow::RESULT_WARNINGS:
           $this->getErrorExcuse(
             'lint',
             'Lint issued unresolved warnings.',
             'lint-excuses');
           break;
         case ArcanistLintWorkflow::RESULT_ERRORS:
           $this->console->writeOut(
             "<bg:red>** LINT ERRORS **</bg> Lint raised errors!\n");
           $this->getErrorExcuse(
             'lint',
             'Lint issued unresolved errors!',
             'lint-excuses');
           break;
         case ArcanistLintWorkflow::RESULT_POSTPONED:
           $this->console->writeOut(
             "<bg:yellow>** LINT POSTPONED **</bg> ".
             "Lint results are postponed.\n");
           break;
       }
 
       $this->unresolvedLint = array();
       foreach ($lint_workflow->getUnresolvedMessages() as $message) {
         $this->unresolvedLint[] = $message->toDictionary();
       }
 
       $this->postponedLinters = $lint_workflow->getPostponedLinters();
 
       return $lint_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut("No lint engine configured for this project.\n");
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut($ex->getMessage()."\n");
     }
 
     return null;
   }
 
 
   /**
    * @task lintunit
    */
   private function runUnit() {
     if ($this->getArgument('nounit') ||
         $this->getArgument('only') ||
         $this->isRawDiffSource() ||
         $this->getArgument('head')) {
       return ArcanistUnitWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("Running unit tests...\n");
     try {
       $argv = $this->getPassthruArgumentsAsArgv('unit');
       if ($repository_api->supportsCommitRanges()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getBaseCommit();
       }
       $unit_workflow = $this->buildChildWorkflow('unit', $argv);
       $unit_result = $unit_workflow->run();
 
       switch ($unit_result) {
         case ArcanistUnitWorkflow::RESULT_OKAY:
           $this->console->writeOut(
             "<bg:green>** UNIT OKAY **</bg> No unit test failures.\n");
           break;
         case ArcanistUnitWorkflow::RESULT_UNSOUND:
           if ($this->getArgument('ignore-unsound-tests')) {
             echo phutil_console_format(
               "<bg:yellow>** UNIT UNSOUND **</bg> Unit testing raised errors, ".
               "but all failing tests are unsound.\n");
           } else {
             $continue = $this->console->confirm(
               'Unit test results included failures, but all failing tests '.
               'are known to be unsound. Ignore unsound test failures?');
             if (!$continue) {
               throw new ArcanistUserAbortException();
             }
           }
           break;
         case ArcanistUnitWorkflow::RESULT_FAIL:
           $this->console->writeOut(
             "<bg:red>** UNIT ERRORS **</bg> Unit testing raised errors!\n");
           $this->getErrorExcuse(
             'unit',
             'Unit test results include failures!',
             'unit-excuses');
           break;
       }
 
       $this->testResults = array();
       foreach ($unit_workflow->getTestResults() as $test) {
         $this->testResults[] = array(
           'name'      => $test->getName(),
           'link'      => $test->getLink(),
           'result'    => $test->getResult(),
           'userdata'  => $test->getUserData(),
           'coverage'  => $test->getCoverage(),
           'extra'     => $test->getExtraData(),
         );
       }
 
       return $unit_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut(
         "No unit test engine is configured for this project.\n");
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut($ex->getMessage()."\n");
     }
 
     return null;
   }
 
   public function getTestResults() {
     return $this->testResults;
   }
 
   private function getSkipExcuse($prompt, $history) {
     $excuse = $this->getArgument('excuse');
 
     if ($excuse === null) {
       $history = $this->getRepositoryAPI()->getScratchFilePath($history);
       $excuse = phutil_console_prompt($prompt, $history);
       if ($excuse == '') {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $excuse;
   }
 
   private function getErrorExcuse($type, $prompt, $history) {
     if ($this->getArgument('excuse')) {
       $this->console->sendMessage(array(
         'type'    => $type,
         'confirm'  => $prompt.' Ignore them?',
       ));
       return;
     }
 
     $history = $this->getRepositoryAPI()->getScratchFilePath($history);
 
     $prompt .= ' Provide explanation to continue or press Enter to abort.';
     $this->console->writeOut("\n\n%s", phutil_console_wrap($prompt));
     $this->console->sendMessage(array(
       'type'    => $type,
       'prompt'  => 'Explanation:',
       'history' => $history,
     ));
   }
 
   public function handleServerMessage(PhutilConsoleMessage $message) {
     $data = $message->getData();
 
     if ($this->getArgument('excuse')) {
       try {
         phutil_console_require_tty();
       } catch (PhutilConsoleStdinNotInteractiveException $ex) {
         $this->excuses[$data['type']] = $this->getArgument('excuse');
         return null;
       }
     }
 
     $response = '';
     if (isset($data['prompt'])) {
       $response = phutil_console_prompt($data['prompt'], idx($data, 'history'));
     } else if (phutil_console_confirm($data['confirm'])) {
       $response = $this->getArgument('excuse');
     }
     if ($response == '') {
       throw new ArcanistUserAbortException();
     }
     $this->excuses[$data['type']] = $response;
     return null;
   }
 
 
 /* -(  Commit and Update Messages  )----------------------------------------- */
 
 
   /**
    * @task message
    */
   private function buildCommitMessage() {
     if ($this->getArgument('preview') || $this->getArgument('only')) {
       return null;
     }
 
     $is_create = $this->getArgument('create');
     $is_update = $this->getArgument('update');
     $is_raw = $this->isRawDiffSource();
     $is_message = $this->getArgument('use-commit-message');
     $is_verbatim = $this->getArgument('verbatim');
 
     if ($is_message) {
       return $this->getCommitMessageFromCommit($is_message);
     }
 
     if ($is_verbatim) {
       return $this->getCommitMessageFromUser();
     }
 
 
     if (!$is_raw && !$is_create && !$is_update) {
       $repository_api = $this->getRepositoryAPI();
       $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
         $this->getConduit(),
         array(
           'authors' => array($this->getUserPHID()),
           'status'  => 'status-open',
         ));
       if (!$revisions) {
         $is_create = true;
       } else if (count($revisions) == 1) {
         $revision = head($revisions);
         $is_update = $revision['id'];
       } else {
         throw new ArcanistUsageException(
           "There are several revisions which match the working copy:\n\n".
           $this->renderRevisionList($revisions)."\n".
           "Use '--update' to choose one, or '--create' to create a new ".
           "revision.");
       }
     }
 
     $message = null;
     if ($is_create) {
       $message_file = $this->getArgument('message-file');
       if ($message_file) {
         return $this->getCommitMessageFromFile($message_file);
       } else {
         return $this->getCommitMessageFromUser();
       }
     } else if ($is_update) {
       $revision_id = $this->normalizeRevisionID($is_update);
       if (!is_numeric($revision_id)) {
         throw new ArcanistUsageException(
           'Parameter to --update must be a Differential Revision number');
       }
       return $this->getCommitMessageFromRevision($revision_id);
     } else {
       // This is --raw without enough info to create a revision, so force just
       // a diff.
       return null;
     }
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromCommit($commit) {
     $text = $this->getRepositoryAPI()->getCommitMessage($commit);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
     $message->pullDataFromConduit($this->getConduit());
     $this->validateCommitMessage($message);
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromUser() {
     $conduit = $this->getConduit();
 
     $template = null;
 
     if (!$this->getArgument('verbatim')) {
       $saved = $this->readScratchFile('create-message');
       if ($saved) {
         $where = $this->getReadableScratchFilePath('create-message');
 
         $preview = explode("\n", $saved);
         $preview = array_shift($preview);
         $preview = trim($preview);
         $preview = phutil_utf8_shorten($preview, 64);
 
         if ($preview) {
           $preview = "Message begins:\n\n       {$preview}\n\n";
         } else {
           $preview = null;
         }
 
         echo
           "You have a saved revision message in '{$where}'.\n".
           "{$preview}".
           "You can use this message, or discard it.";
 
         $use = phutil_console_confirm(
           'Do you want to use this message?',
           $default_no = false);
         if ($use) {
           $template = $saved;
         } else {
           $this->removeScratchFile('create-message');
         }
       }
     }
 
     $template_is_default = false;
     $notes = array();
     $included = array();
 
     list($fields, $notes, $included_commits) = $this->getDefaultCreateFields();
     if ($template) {
       $fields = array();
       $notes = array();
     } else {
       if (!$fields) {
         $template_is_default = true;
       }
 
       if ($notes) {
         $commit = head($this->getRepositoryAPI()->getLocalCommitInformation());
         $template = $commit['message'];
       } else {
         $template = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => null,
             'edit'        => 'create',
             'fields'      => $fields,
           ));
       }
     }
 
     $old_message = $template;
 
     $included = array();
     if ($included_commits) {
       foreach ($included_commits as $commit) {
         $included[] = '        '.$commit;
       }
       $in_branch = '';
       if (!$this->isRawDiffSource()) {
         $in_branch = ' in branch '.$this->getRepositoryAPI()->getBranchName();
       }
       $included = array_merge(
         array(
           '',
           "Included commits{$in_branch}:",
           '',
         ),
         $included);
     }
 
     $issues = array_merge(
       array(
         'NEW DIFFERENTIAL REVISION',
         'Describe the changes in this new revision.',
       ),
       $included,
       array(
         '',
         'arc could not identify any existing revision in your working copy.',
         'If you intended to update an existing revision, use:',
         '',
         '  $ arc diff --update <revision>',
       ));
     if ($notes) {
       $issues = array_merge($issues, array(''), $notes);
     }
 
     $done = false;
     $first = true;
     while (!$done) {
       $template = rtrim($template, "\r\n")."\n\n";
       foreach ($issues as $issue) {
         $template .= '# '.$issue."\n";
       }
       $template .= "\n";
 
       if ($first && $this->getArgument('verbatim') && !$template_is_default) {
         $new_template = $template;
       } else {
         $new_template = $this->newInteractiveEditor($template)
           ->setName('new-commit')
           ->editInteractively();
       }
       $first = false;
 
       if ($template_is_default && ($new_template == $template)) {
         throw new ArcanistUsageException('Template not edited.');
       }
 
       $template = ArcanistCommentRemover::removeComments($new_template);
 
       // With --raw-command, we may not have a repository API.
       if ($this->hasRepositoryAPI()) {
         $repository_api = $this->getRepositoryAPI();
         // special check for whether to amend here. optimizes a common git
         // workflow. we can't do this for mercurial because the mq extension
         // is popular and incompatible with hg commit --amend ; see T2011.
         $should_amend = (count($included_commits) == 1 &&
                          $repository_api instanceof ArcanistGitAPI &&
                          $this->shouldAmend());
       } else {
         $should_amend = false;
       }
 
       if ($should_amend) {
         $wrote = (rtrim($old_message) != rtrim($template));
         if ($wrote) {
           $repository_api->amendCommit($template);
           $where = 'commit message';
         }
       } else {
         $wrote = $this->writeScratchFile('create-message', $template);
         $where = "'".$this->getReadableScratchFilePath('create-message')."'";
       }
 
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $template);
         $message->pullDataFromConduit($conduit);
         $this->validateCommitMessage($message);
         $done = true;
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         echo "Commit message has errors:\n\n";
         $issues = array('Resolve these errors:');
         foreach ($ex->getParserErrors() as $error) {
           echo phutil_console_wrap("- ".$error."\n", 6);
           $issues[] = '  - '.$error;
         }
         echo "\n";
         echo 'You must resolve these errors to continue.';
         $again = phutil_console_confirm(
           'Do you want to edit the message?',
           $default_no = false);
         if ($again) {
           // Keep going.
         } else {
           $saved = null;
           if ($wrote) {
             $saved = "A copy was saved to {$where}.";
           }
           throw new ArcanistUsageException(
             "Message has unresolved errrors. {$saved}");
         }
       } catch (Exception $ex) {
         if ($wrote) {
           echo phutil_console_wrap("(Message saved to {$where}.)\n");
         }
         throw $ex;
       }
     }
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromFile($file) {
     $conduit = $this->getConduit();
 
     $data = Filesystem::readFile($file);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($data);
     $message->pullDataFromConduit($conduit);
 
     $this->validateCommitMessage($message);
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromRevision($revision_id) {
     $id = $revision_id;
 
     $revision = $this->getConduit()->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($id),
       ));
     $revision = head($revision);
 
     if (!$revision) {
       throw new ArcanistUsageException(
         "Revision '{$revision_id}' does not exist!");
     }
 
     $this->checkRevisionOwnership($revision);
 
     $message = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => $id,
         'edit'        => false,
       ));
     $this->commitMessageFromRevision = $message;
 
     $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
     $obj->pullDataFromConduit($this->getConduit());
 
     return $obj;
   }
 
 
   /**
    * @task message
    */
   private function validateCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
     $futures = array();
 
     $revision_id = $message->getRevisionID();
     if ($revision_id) {
       $futures['revision'] = $this->getConduit()->callMethod(
         'differential.query',
         array(
           'ids' => array($revision_id),
         ));
     }
 
     $reviewers = $message->getFieldValue('reviewerPHIDs');
     if (!$reviewers) {
       $confirm = 'You have not specified any reviewers. Continue anyway?';
       if (!phutil_console_confirm($confirm)) {
         throw new ArcanistUsageException('Specify reviewers and retry.');
       }
     } else {
       $futures['reviewers'] = $this->getConduit()->callMethod(
         'user.query',
         array(
           'phids' => $reviewers,
         ));
     }
 
     foreach (Futures($futures) as $key => $future) {
       $result = $future->resolve();
       switch ($key) {
         case 'revision':
           if (empty($result)) {
             throw new ArcanistUsageException(
               "There is no revision D{$revision_id}.");
           }
           $this->checkRevisionOwnership(head($result));
           break;
         case 'reviewers':
           $untils = array();
           foreach ($result as $user) {
             if (idx($user, 'currentStatus') == 'away') {
               $untils[] = $user['currentStatusUntil'];
             }
           }
           if (count($untils) == count($reviewers)) {
             $until = date('l, M j Y', min($untils));
             $confirm = "All reviewers are away until {$until}. ".
                        "Continue anyway?";
             if (!phutil_console_confirm($confirm)) {
               throw new ArcanistUsageException(
                 'Specify available reviewers and retry.');
             }
           }
           break;
       }
     }
 
   }
 
 
   /**
    * @task message
    */
   private function getUpdateMessage(array $fields, $template = '') {
     if ($this->getArgument('raw')) {
       throw new ArcanistUsageException(
         "When using '--raw' to update a revision, specify an update message ".
         "with '--message'. (Normally, we'd launch an editor to ask you for a ".
         "message, but can not do that because stdin is the diff source.)");
     }
 
     // When updating a revision using git without specifying '--message', try
     // to prefill with the message in HEAD if it isn't a template message. The
     // idea is that if you do:
     //
     //  $ git commit -a -m 'fix some junk'
     //  $ arc diff
     //
     // ...you shouldn't have to retype the update message. Similar things apply
     // to Mercurial.
 
     if ($template == '') {
       $comments = $this->getDefaultUpdateMessage();
 
       $template =
         rtrim($comments).
         "\n\n".
         "# Updating D{$fields['revisionID']}: {$fields['title']}\n".
         "#\n".
         "# Enter a brief description of the changes included in this update.\n".
         "# The first line is used as subject, next lines as comment.\n".
         "#\n".
         "# If you intended to create a new revision, use:\n".
         "#  $ arc diff --create\n".
         "\n";
     }
 
     $comments = $this->newInteractiveEditor($template)
       ->setName('differential-update-comments')
       ->editInteractively();
 
     return $comments;
   }
 
   private function getDefaultCreateFields() {
     $result = array(array(), array(), array());
 
     if ($this->isRawDiffSource()) {
       return $result;
     }
 
     $repository_api = $this->getRepositoryAPI();
     $local = $repository_api->getLocalCommitInformation();
     if ($local) {
       $result = $this->parseCommitMessagesIntoFields($local);
       if ($this->getArgument('create')) {
         unset($result[0]['revisionID']);
       }
     }
 
     $result[0] = $this->dispatchWillBuildEvent($result[0]);
 
     return $result;
   }
 
   /**
    * Convert a list of commits from `getLocalCommitInformation()` into
    * a format usable by arc to create a new diff. Specifically, we emit:
    *
    *   - A dictionary of commit message fields.
    *   - A list of errors encountered while parsing the messages.
    *   - A human-readable list of the commits themselves.
    *
    * For example, if the user runs "arc diff HEAD^^^" and selects a diff range
    * which includes several diffs, we attempt to merge them somewhat
    * intelligently into a single message, because we can only send one
    * "Summary:", "Reviewers:", etc., field to Differential. We also return
    * errors (e.g., if the user typed a reviewer name incorrectly) and a
    * summary of the commits themselves.
    *
    * @param dict  Local commit information.
    * @return list Complex output, see summary.
    * @task message
    */
   private function parseCommitMessagesIntoFields(array $local) {
     $conduit = $this->getConduit();
     $local = ipull($local, null, 'commit');
 
     // If the user provided "--reviewers" or "--ccs", add a faux message to
     // the list with the implied fields.
 
     $faux_message = array();
     if ($this->getArgument('reviewers')) {
       $faux_message[] = 'Reviewers: '.$this->getArgument('reviewers');
     }
     if ($this->getArgument('cc')) {
       $faux_message[] = 'CC: '.$this->getArgument('cc');
     }
 
     if ($faux_message) {
       $faux_message = implode("\n\n", $faux_message);
       $local = array(
         '(Flags)     ' => array(
           'message' => $faux_message,
           'summary' => 'Command-Line Flags',
         ),
       ) + $local;
     }
 
     // Build a human-readable list of the commits, so we can show the user which
     // commits are included in the diff.
     $included = array();
     foreach ($local as $hash => $info) {
       $included[] = substr($hash, 0, 12).' '.$info['summary'];
     }
 
     // Parse all of the messages into fields.
     $messages = array();
     foreach ($local as $hash => $info) {
       $text = $info['message'];
       if (trim($text) == self::AUTO_COMMIT_TITLE) {
         continue;
       }
       $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       $messages[$hash] = $obj;
     }
 
     $notes = array();
     $fields = array();
     foreach ($messages as $hash => $message) {
       try {
         $message->pullDataFromConduit($conduit, $partial = true);
         $fields[$hash] = $message->getFields();
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         if ($this->getArgument('verbatim')) {
           // In verbatim mode, just bail when we hit an error. The user can
           // rerun without --verbatim if they want to fix it manually. Most
           // users will probably `git commit --amend` instead.
           throw $ex;
         }
         $fields[$hash] = $message->getFields();
 
         $frev = substr($hash, 0, 12);
         $notes[] = "NOTE: commit {$frev} could not be completely parsed:";
         foreach ($ex->getParserErrors() as $error) {
           $notes[] = "  - {$error}";
         }
       }
     }
 
     // Merge commit message fields. We do this somewhat-intelligently so that
     // multiple "Reviewers" or "CC" fields will merge into the concatenation
     // of all values.
 
     // We have special parsing rules for 'title' because we can't merge
     // multiple titles, and one-line commit messages like "fix stuff" will
     // parse as titles. Instead, pick the first title we encounter. When we
     // encounter subsequent titles, treat them as part of the summary. Then
     // we merge all the summaries together below.
 
     $result = array();
 
     // Process fields in oldest-first order, so earlier commits get to set the
     // title of record and reviewers/ccs are listed in chronological order.
     $fields = array_reverse($fields);
 
     foreach ($fields as $hash => $dict) {
       $title = idx($dict, 'title');
       if (!strlen($title)) {
         continue;
       }
 
       if (!isset($result['title'])) {
         // We don't have a title yet, so use this one.
         $result['title'] = $title;
       } else {
         // We already have a title, so merge this new title into the summary.
         $summary = idx($dict, 'summary');
         if ($summary) {
           $summary = $title."\n\n".$summary;
         } else {
           $summary = $title;
         }
         $fields[$hash]['summary'] = $summary;
       }
     }
 
     // Now, merge all the other fields in a general sort of way.
 
     foreach ($fields as $hash => $dict) {
       foreach ($dict as $key => $value) {
         if ($key == 'title') {
           // This has been handled above, and either assigned directly or
           // merged into the summary.
           continue;
         }
 
         if (is_array($value)) {
           // For array values, merge the arrays, appending the new values.
           // Examples are "Reviewers" and "Cc", where this produces a list of
           // all users specified as reviewers.
           $cur = idx($result, $key, array());
           $new = array_merge($cur, $value);
           $result[$key] = $new;
           continue;
         } else {
           if (!strlen(trim($value))) {
             // Ignore empty fields.
             continue;
           }
 
           // For string values, append the new field to the old field with
           // a blank line separating them. Examples are "Test Plan" and
           // "Summary".
           $cur = idx($result, $key, '');
           if (strlen($cur)) {
             $new = $cur."\n\n".$value;
           } else {
             $new = $value;
           }
           $result[$key] = $new;
         }
       }
     }
 
     return array($result, $notes, $included);
   }
 
   private function getDefaultUpdateMessage() {
     if ($this->isRawDiffSource()) {
       return null;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistGitAPI) {
       return $this->getGitUpdateMessage();
     }
 
     if ($repository_api instanceof ArcanistMercurialAPI) {
       return $this->getMercurialUpdateMessage();
     }
 
     return null;
   }
 
   /**
    * Retrieve the git messages between HEAD and the last update.
    *
    * @task message
    */
   private function getGitUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $parser = $this->newDiffParser();
     $commit_messages = $repository_api->getGitCommitLog();
     $commit_messages = $parser->parseDiff($commit_messages);
 
     if (count($commit_messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     // We have more than one message, so figure out which ones are new. We
     // do this by pulling the current diff and comparing commit hashes in the
     // working copy with attached commit hashes. It's not super important that
     // we always get this 100% right, we're just trying to do something
     // reasonable.
 
     $local = $this->loadActiveLocalCommitInfo();
     $hashes = ipull($local, null, 'commit');
 
     $usable = array();
     foreach ($commit_messages as $message) {
       $text = $message->getMetadata('message');
 
       $parsed = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       if ($parsed->getRevisionID()) {
         // If this is an amended commit message with a revision ID, it's
         // certainly not new. Stop marking commits as usable and break out.
         break;
       }
 
       if (isset($hashes[$message->getCommitHash()])) {
         // If this commit is currently part of the diff, stop using commit
         // messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $text;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
   /**
    * Retrieve the hg messages between tip and the last update.
    *
    * @task message
    */
   private function getMercurialUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $messages = $repository_api->getCommitMessageLog();
 
     if (count($messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     $local = $this->loadActiveLocalCommitInfo();
     $hashes = ipull($local, null, 'commit');
 
     $usable = array();
     foreach ($messages as $rev => $message) {
       if (isset($hashes[$rev])) {
         // If this commit is currently part of the active diff on the revision,
         // stop using commit messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $message;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
 
   /**
    * Format log messages to prefill a diff update.
    *
    * @task message
    */
   private function formatUsableLogs(array $usable) {
     // Flip messages so they'll read chronologically (oldest-first) in the
     // template, e.g.:
     //
     //   - Added foobar.
     //   - Fixed foobar bug.
     //   - Documented foobar.
 
     $usable = array_reverse($usable);
     $default = array();
     foreach ($usable as $message) {
       // Pick the first line out of each message.
       $text = trim($message);
       if ($text == self::AUTO_COMMIT_TITLE) {
         continue;
       }
       $text = head(explode("\n", $text));
       $default[] = '  - '.$text."\n";
     }
 
     return implode('', $default);
   }
 
   private function loadActiveLocalCommitInfo() {
     $current_diff = $this->getConduit()->callMethodSynchronous(
       'differential.getdiff',
       array(
         'revision_id' => $this->revisionID,
       ));
 
     $properties = idx($current_diff, 'properties', array());
     return idx($properties, 'local:commits', array());
   }
 
 
 /* -(  Diff Specification  )------------------------------------------------- */
 
 
   /**
    * @task diffspec
    */
   private function getLintStatus($lint_result) {
     $map = array(
       ArcanistLintWorkflow::RESULT_OKAY       => 'okay',
       ArcanistLintWorkflow::RESULT_ERRORS     => 'fail',
       ArcanistLintWorkflow::RESULT_WARNINGS   => 'warn',
       ArcanistLintWorkflow::RESULT_SKIP       => 'skip',
       ArcanistLintWorkflow::RESULT_POSTPONED  => 'postponed',
     );
     return idx($map, $lint_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function getUnitStatus($unit_result) {
     $map = array(
       ArcanistUnitWorkflow::RESULT_OKAY       => 'okay',
       ArcanistUnitWorkflow::RESULT_FAIL       => 'fail',
       ArcanistUnitWorkflow::RESULT_UNSOUND    => 'warn',
       ArcanistUnitWorkflow::RESULT_SKIP       => 'skip',
       ArcanistUnitWorkflow::RESULT_POSTPONED  => 'postponed',
     );
     return idx($map, $unit_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function buildDiffSpecification() {
 
     $base_revision  = null;
     $base_path      = null;
     $vcs            = null;
     $repo_uuid      = null;
     $parent         = null;
     $source_path    = null;
     $branch         = null;
     $bookmark       = null;
 
     if (!$this->isRawDiffSource()) {
       $repository_api = $this->getRepositoryAPI();
 
       $base_revision  = $repository_api->getSourceControlBaseRevision();
       $base_path      = $repository_api->getSourceControlPath();
       $vcs            = $repository_api->getSourceControlSystemName();
       $source_path    = $repository_api->getPath();
       $branch         = $repository_api->getBranchName();
       $repo_uuid      = $repository_api->getRepositoryUUID();
 
       if ($repository_api instanceof ArcanistGitAPI) {
         $info = $this->getGitParentLogInfo();
         if ($info['parent']) {
           $parent = $info['parent'];
         }
         if ($info['base_revision']) {
           $base_revision = $info['base_revision'];
         }
         if ($info['base_path']) {
           $base_path = $info['base_path'];
         }
         if ($info['uuid']) {
           $repo_uuid = $info['uuid'];
         }
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
 
         $bookmark = $repository_api->getActiveBookmark();
         $svn_info = $repository_api->getSubversionInfo();
         $repo_uuid = idx($svn_info, 'uuid');
         $base_path = idx($svn_info, 'base_path', $base_path);
         $base_revision = idx($svn_info, 'base_revision', $base_revision);
 
         // TODO: provide parent info
 
       }
     }
 
     $project_id = null;
     if ($this->requiresWorkingCopy()) {
       $project_id = $this->getWorkingCopy()->getProjectID();
     }
 
     $data = array(
       'sourceMachine'             => php_uname('n'),
       'sourcePath'                => $source_path,
       'branch'                    => $branch,
       'bookmark'                  => $bookmark,
       'sourceControlSystem'       => $vcs,
       'sourceControlPath'         => $base_path,
       'sourceControlBaseRevision' => $base_revision,
       'creationMethod'            => 'arc',
       'arcanistProject'           => $project_id,
     );
 
     if (!$this->isRawDiffSource()) {
       $repository_phid = $this->getRepositoryPHID();
       if ($repository_phid) {
         $data['repositoryPHID'] = $repository_phid;
       }
     }
 
     return $data;
   }
 
 
 /* -(  Diff Properties  )---------------------------------------------------- */
 
 
   /**
    * Update lint information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateLintDiffProperty() {
     if (strlen($this->excuses['lint'])) {
       $this->updateDiffProperty('arc:lint-excuse',
         json_encode($this->excuses['lint']));
     }
 
     if ($this->unresolvedLint) {
       $this->updateDiffProperty('arc:lint', json_encode($this->unresolvedLint));
     }
 
     $postponed = $this->postponedLinters;
     if ($postponed) {
       $this->updateDiffProperty('arc:lint-postponed', json_encode($postponed));
     }
 
   }
 
 
   /**
    * Update unit test information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateUnitDiffProperty() {
     if (strlen($this->excuses['unit'])) {
       $this->updateDiffProperty('arc:unit-excuse',
         json_encode($this->excuses['unit']));
     }
 
     if ($this->testResults) {
       $this->updateDiffProperty('arc:unit', json_encode($this->testResults));
     }
   }
 
 
   /**
    * Update local commit information for the diff.
    *
    * @task diffprop
    */
   private function updateLocalDiffProperty() {
     if ($this->isRawDiffSource()) {
       return;
     }
 
     $local_info = $this->getRepositoryAPI()->getLocalCommitInformation();
     if (!$local_info) {
       return;
     }
 
     $this->updateDiffProperty('local:commits', json_encode($local_info));
   }
 
 
   /**
    * Update an arbitrary diff property.
    *
    * @param string Diff property name.
    * @param string Diff property value.
    * @return void
    *
    * @task diffprop
    */
   private function updateDiffProperty($name, $data) {
     $this->diffPropertyFutures[] = $this->getConduit()->callMethod(
       'differential.setdiffproperty',
       array(
         'diff_id' => $this->getDiffID(),
         'name'    => $name,
         'data'    => $data,
       ));
   }
 
   /**
    * Wait for finishing all diff property updates.
    *
    * @return void
    *
    * @task diffprop
    */
   private function resolveDiffPropertyUpdates() {
     Futures($this->diffPropertyFutures)->resolveAll();
     $this->diffPropertyFutures = array();
   }
 
   private function dispatchWillCreateRevisionEvent(array $fields) {
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_REVISION_WILLCREATEREVISION,
       array(
         'specification' => $fields,
       ));
 
     return $event->getValue('specification');
   }
 
   private function dispatchWillBuildEvent(array $fields) {
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_WILLBUILDMESSAGE,
       array(
         'fields' => $fields,
       ));
 
     return $event->getValue('fields');
   }
 
   private function checkRevisionOwnership(array $revision) {
     if ($revision['authorPHID'] == $this->getUserPHID()) {
       return;
     }
 
     $id = $revision['id'];
     $title = $revision['title'];
 
     throw new ArcanistUsageException(
       "You don't own revision D{$id} '{$title}'. You can only update ".
       "revisions you own. You can 'Commandeer' this revision from the web ".
       "interface if you want to become the owner.");
   }
 
 
 /* -(  File Uploads  )------------------------------------------------------- */
 
 
   private function uploadFilesForChanges(array $changes) {
     assert_instances_of($changes, 'ArcanistDiffChange');
 
     // Collect all the files we need to upload.
 
     $need_upload = array();
     foreach ($changes as $key => $change) {
       if ($change->getFileType() != ArcanistDiffChangeType::FILE_BINARY) {
         continue;
       }
 
       if ($this->getArgument('skip-binaries')) {
         continue;
       }
 
       $name = basename($change->getCurrentPath());
 
       $need_upload[] = array(
         'type' => 'old',
         'name' => $name,
         'data' => $change->getOriginalFileData(),
         'change' => $change,
       );
 
       $need_upload[] = array(
         'type' => 'new',
         'name' => $name,
         'data' => $change->getCurrentFileData(),
         'change' => $change,
       );
     }
 
     if (!$need_upload) {
       return;
     }
 
     // Determine mime types and file sizes. Update changes from "binary" to
     // "image" if the file is an image. Set image metadata.
 
     $type_image = ArcanistDiffChangeType::FILE_IMAGE;
     foreach ($need_upload as $key => $spec) {
       $change = $need_upload[$key]['change'];
 
       $type = $spec['type'];
       $size = strlen($spec['data']);
 
       $change->setMetadata("{$type}:file:size", $size);
       if ($spec['data'] === null) {
         // This covers the case where a file was added or removed; we don't
         // need to upload the other half of it (e.g., the old file data for
         // a file which was just added). This is distinct from an empty
         // file, which we do upload.
         unset($need_upload[$key]);
         continue;
       }
 
       $mime = $this->getFileMimeType($spec['data']);
       if (preg_match('@^image/@', $mime)) {
         $change->setFileType($type_image);
       }
 
       $change->setMetadata("{$type}:file:mime-type", $mime);
     }
 
     echo pht('Uploading %d files...', count($need_upload))."\n";
 
     // Now we're ready to upload the actual file data. If possible, we'll just
     // transmit a hash of the file instead of the actual file data. If the data
     // already exists, Phabricator can share storage. Check if we can use
     // "file.uploadhash" yet (i.e., if the server is up to date enough).
     // TODO: Drop this check once we bump the protocol version.
     $conduit_methods = $this->getConduit()->callMethodSynchronous(
       'conduit.query',
       array());
     $can_use_hash_upload = isset($conduit_methods['file.uploadhash']);
 
     if ($can_use_hash_upload) {
       $hash_futures = array();
       foreach ($need_upload as $key => $spec) {
         $hash_futures[$key] = $this->getConduit()->callMethod(
           'file.uploadhash',
           array(
             'name' => $spec['name'],
             'hash' => sha1($spec['data']),
           ));
       }
 
       foreach (Futures($hash_futures)->limit(8) as $key => $future) {
         $type = $need_upload[$key]['type'];
         $change = $need_upload[$key]['change'];
         $name = $need_upload[$key]['name'];
 
         $phid = null;
         try {
           $phid = $future->resolve();
         } catch (Exception $e) {
           // Just try uploading normally if the hash upload failed.
           continue;
         }
 
         if ($phid) {
           $change->setMetadata("{$type}:binary-phid", $phid);
           unset($need_upload[$key]);
           echo pht("Uploaded '%s' (%s).", $name, $type)."\n";
         }
       }
     }
 
     $upload_futures = array();
     foreach ($need_upload as $key => $spec) {
       $upload_futures[$key] = $this->getConduit()->callMethod(
         'file.upload',
         array(
           'name' => $spec['name'],
           'data_base64' => base64_encode($spec['data']),
         ));
     }
 
     foreach (Futures($upload_futures)->limit(4) as $key => $future) {
       $type = $need_upload[$key]['type'];
       $change = $need_upload[$key]['change'];
       $name = $need_upload[$key]['name'];
 
       try {
         $phid = $future->resolve();
         $change->setMetadata("{$type}:binary-phid", $phid);
         echo pht("Uploaded '%s' (%s).", $name, $type)."\n";
       } catch (Exception $e) {
         echo "Failed to upload {$type} binary '{$name}'.\n\n";
         echo $e->getMessage()."\n";
         if (!phutil_console_confirm('Continue?', $default_no = false)) {
           throw new ArcanistUsageException(
             'Aborted due to file upload failure. You can use --skip-binaries '.
             'to skip binary uploads.');
         }
       }
     }
 
     echo pht('Upload complete.')."\n";
   }
 
   private function getFileMimeType($data) {
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $data);
     return Filesystem::getMimeType($tmp);
   }
 
 }
diff --git a/src/workflow/ArcanistDownloadWorkflow.php b/src/workflow/ArcanistDownloadWorkflow.php
index 25a002f0..d7a8ce72 100644
--- a/src/workflow/ArcanistDownloadWorkflow.php
+++ b/src/workflow/ArcanistDownloadWorkflow.php
@@ -1,113 +1,112 @@
 <?php
 
 /**
  * Download a file from Phabricator.
- *
- * @group workflow
  */
 final class ArcanistDownloadWorkflow extends ArcanistBaseWorkflow {
 
   private $id;
   private $saveAs;
   private $show;
 
   public function getWorkflowName() {
     return 'download';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **download** __file__ [--as __name__] [--show]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: filesystems
           Download a file to local disk, e.g.:
 
             $ arc download F33              # Download file 'F33'
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'show' => array(
         'conflicts' => array(
-          'as' => 'Use --show to direct the file to stdout, or --as to direct '.
-                  'it to a named location.',
+          'as' =>
+            'Use --show to direct the file to stdout, or --as to direct '.
+            'it to a named location.',
         ),
         'help' => 'Write file to stdout instead of to disk.',
       ),
       'as' => array(
         'param' => 'name',
         'help' => 'Save the file with a specific name rather than the default.',
       ),
       '*' => 'argv',
     );
   }
 
   protected function didParseArguments() {
     $argv = $this->getArgument('argv');
     if (!$argv) {
       throw new ArcanistUsageException('Specify a file to download.');
     }
     if (count($argv) > 1) {
       throw new ArcanistUsageException('Specify exactly one file to download.');
     }
 
     $file = reset($argv);
     if (!preg_match('/^F?\d+$/', $file)) {
       throw new ArcanistUsageException('Specify file by ID, e.g. F123.');
     }
 
     $this->id = (int)ltrim($file, 'F');
     $this->saveAs = $this->getArgument('as');
     $this->show = $this->getArgument('show');
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function run() {
 
     $conduit = $this->getConduit();
 
     $this->writeStatusMessage("Getting file information...\n");
     $info = $conduit->callMethodSynchronous(
       'file.info',
       array(
         'id' => $this->id,
       ));
 
     $bytes = number_format($info['byteSize']);
     $desc = '('.$bytes.' bytes)';
     if ($info['name']) {
       $desc = "'".$info['name']."' ".$desc;
     }
 
     $this->writeStatusMessage("Downloading file {$desc}...\n");
     $data = $conduit->callMethodSynchronous(
       'file.download',
       array(
         'phid' => $info['phid'],
       ));
 
     $data = base64_decode($data);
 
     if ($this->show) {
       echo $data;
     } else {
       $path = Filesystem::writeUniqueFile(
         nonempty($this->saveAs, $info['name'], 'file'),
         $data);
       $this->writeStatusMessage("Saved file as '{$path}'.\n");
     }
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistExportWorkflow.php b/src/workflow/ArcanistExportWorkflow.php
index 481f0c5b..541fdf50 100644
--- a/src/workflow/ArcanistExportWorkflow.php
+++ b/src/workflow/ArcanistExportWorkflow.php
@@ -1,276 +1,272 @@
 <?php
 
 /**
  * Exports changes from Differential or the working copy to a file.
- *
- * @group workflow
  */
 final class ArcanistExportWorkflow extends ArcanistBaseWorkflow {
 
   const SOURCE_LOCAL      = 'local';
   const SOURCE_DIFF       = 'diff';
   const SOURCE_REVISION   = 'revision';
 
   const FORMAT_GIT        = 'git';
   const FORMAT_UNIFIED    = 'unified';
   const FORMAT_BUNDLE     = 'arcbundle';
 
   private $source;
   private $sourceID;
   private $format;
 
   public function getWorkflowName() {
     return 'export';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **export** [__paths__] __format__ (svn)
       **export** [__commit_range__] __format__ (git, hg)
       **export** __--revision__ __revision_id__ __format__
       **export** __--diff__ __diff_id__ __format__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn, git, hg
           Export the local changeset (or a Differential changeset) to a file,
           in some __format__: git diff (__--git__), unified diff
           (__--unified__), or arc bundle (__--arcbundle__ __path__) format.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'git' => array(
         'help' =>
           "Export change as a git patch. This format is more complete than ".
           "unified, but less complete than arc bundles. These patches can be ".
           "applied with 'git apply' or 'arc patch'.",
       ),
       'unified' => array(
         'help' =>
           "Export change as a unified patch. This format is less complete ".
           "than git patches or arc bundles. These patches can be applied with ".
           "'patch' or 'arc patch'.",
       ),
       'arcbundle' => array(
         'param' => 'file',
         'help' =>
           "Export change as an arc bundle. This format can represent all ".
           "changes. These bundles can be applied with 'arc patch'.",
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           'Attempt to convert non UTF-8 patch into specified encoding.',
       ),
       'revision' => array(
         'param' => 'revision_id',
         'help' =>
           'Instead of exporting changes from the working copy, export them '.
           'from a Differential revision.'
       ),
       'diff' => array(
         'param' => 'diff_id',
         'help' =>
           'Instead of exporting changes from the working copy, export them '.
           'from a Differential diff.'
       ),
       '*' => 'paths',
     );
   }
 
-
   protected function didParseArguments() {
     $source = self::SOURCE_LOCAL;
     $requested = 0;
     if ($this->getArgument('revision')) {
       $source = self::SOURCE_REVISION;
       $requested++;
 
       $source_id = $this->getArgument($source);
       $this->sourceID = $this->normalizeRevisionID($source_id);
     }
     if ($this->getArgument('diff')) {
       $source = self::SOURCE_DIFF;
       $requested++;
 
       $this->sourceID = $this->getArgument($source);
     }
     $this->source = $source;
 
     if ($requested > 1) {
       throw new ArcanistUsageException(
-      "Options '--revision' and '--diff' are not compatible. Choose exactly ".
-      "one change source.");
+        "Options '--revision' and '--diff' are not compatible. Choose exactly ".
+        "one change source.");
     }
 
-
     $format = null;
     $requested = 0;
     if ($this->getArgument('git')) {
       $format = self::FORMAT_GIT;
       $requested++;
     }
     if ($this->getArgument('unified')) {
       $format = self::FORMAT_UNIFIED;
       $requested++;
     }
     if ($this->getArgument('arcbundle')) {
       $format = self::FORMAT_BUNDLE;
       $requested++;
     }
 
     if ($requested === 0) {
       throw new ArcanistUsageException(
         "Specify one of '--git', '--unified' or '--arcbundle <path>' to ".
         "choose an export format.");
     } else if ($requested > 1) {
       throw new ArcanistUsageException(
         "Options '--git', '--unified' and '--arcbundle' are not compatible. ".
         "Choose exactly one export format.");
     }
 
     $this->format = $format;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return $this->requiresConduit();
   }
 
   public function requiresRepositoryAPI() {
     return $this->getSource() == self::SOURCE_LOCAL;
   }
 
   public function requiresWorkingCopy() {
     return $this->getSource() == self::SOURCE_LOCAL;
   }
 
   private function getSource() {
     return $this->source;
   }
 
   private function getSourceID() {
     return $this->sourceID;
   }
 
   private function getFormat() {
     return $this->format;
   }
 
   public function run() {
-
     $source = $this->getSource();
 
     switch ($source) {
       case self::SOURCE_LOCAL:
         $repository_api = $this->getRepositoryAPI();
         $parser = new ArcanistDiffParser();
         $parser->setRepositoryAPI($repository_api);
 
         if ($repository_api instanceof ArcanistGitAPI) {
           $this->parseBaseCommitArgument($this->getArgument('paths'));
           $diff = $repository_api->getFullGitDiff(
             $repository_api->getBaseCommit(),
             $repository_api->getHeadCommit());
           $changes = $parser->parseDiff($diff);
           $authors = $this->getConduit()->callMethodSynchronous(
             'user.query',
             array(
               'phids' => array($this->getUserPHID()),
             ));
           $author_dict = reset($authors);
 
           list($email) = $repository_api->execxLocal('config user.email');
 
           $author = sprintf('%s <%s>',
             $author_dict['realName'],
             $email);
         } else if ($repository_api instanceof ArcanistMercurialAPI) {
           $this->parseBaseCommitArgument($this->getArgument('paths'));
           $diff = $repository_api->getFullMercurialDiff();
           $changes = $parser->parseDiff($diff);
           $authors = $this->getConduit()->callMethodSynchronous(
             'user.query',
             array(
               'phids' => array($this->getUserPHID()),
             ));
 
           list($author) = $repository_api->execxLocal('showconfig ui.username');
         } else {
           // TODO: paths support
           $paths = $repository_api->getWorkingCopyStatus();
           $changes = $parser->parseSubversionDiff(
             $repository_api,
             $paths);
           $author = $this->getUserName();
         }
 
         $bundle = ArcanistBundle::newFromChanges($changes);
         $bundle->setProjectID($this->getWorkingCopy()->getProjectID());
         $bundle->setBaseRevision(
           $repository_api->getSourceControlBaseRevision());
-        // note we can't get a revision ID for SOURCE_LOCAL
+        // NOTE: we can't get a revision ID for SOURCE_LOCAL
 
         $parser = new PhutilEmailAddress($author);
         $bundle->setAuthorName($parser->getDisplayName());
         $bundle->setAuthorEmail($parser->getAddress());
         break;
       case self::SOURCE_REVISION:
         $bundle = $this->loadRevisionBundleFromConduit(
           $this->getConduit(),
           $this->getSourceID());
         break;
       case self::SOURCE_DIFF:
         $bundle = $this->loadDiffBundleFromConduit(
           $this->getConduit(),
           $this->getSourceID());
         break;
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
     if (!$try_encoding) {
       try {
         $project_info = $this->getConduit()->callMethodSynchronous(
           'arcanist.projectinfo',
           array(
             'name' => $bundle->getProjectID(),
           ));
         $try_encoding = $project_info['encoding'];
       } catch (ConduitClientException $e) {
         $try_encoding = null;
       }
     }
 
     if ($try_encoding) {
       $bundle->setEncoding($try_encoding);
     }
 
     $format = $this->getFormat();
 
     switch ($format) {
       case self::FORMAT_GIT:
         echo $bundle->toGitPatch();
         break;
       case self::FORMAT_UNIFIED:
         echo $bundle->toUnifiedDiff();
         break;
       case self::FORMAT_BUNDLE:
         $path = $this->getArgument('arcbundle');
         echo "Writing bundle to '{$path}'...\n";
         $bundle->writeToDisk($path);
         echo "done.\n";
         break;
     }
 
     return 0;
   }
+
 }
diff --git a/src/workflow/ArcanistFeatureWorkflow.php b/src/workflow/ArcanistFeatureWorkflow.php
index 4805d22b..5a5651df 100644
--- a/src/workflow/ArcanistFeatureWorkflow.php
+++ b/src/workflow/ArcanistFeatureWorkflow.php
@@ -1,367 +1,366 @@
 <?php
 
 /**
- * Displays user's Git branches or Mercurial bookmarks
+ * Displays user's Git branches or Mercurial bookmarks.
  *
- * @group workflow
  * @concrete-extensible
  */
 class ArcanistFeatureWorkflow extends ArcanistBaseWorkflow {
 
   private $branches;
 
   public function getWorkflowName() {
     return 'feature';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **feature** [__options__]
       **feature** __name__ [__start__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg
           A wrapper on 'git branch' or 'hg bookmark'.
 
           Without __name__, it lists the available branches and their revision
           status.
 
           With __name__, it creates or checks out a branch. If the branch
           __name__ doesn't exist and is in format D123 then the branch of
           revision D123 is checked out. Use __start__ to specify where the new
           branch will start. Use 'arc.feature.start.default' to set the default
           feature start location.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresAuthentication() {
     return !$this->getArgument('branch');
   }
 
   public function getArguments() {
     return array(
       'view-all' => array(
         'help' => 'Include closed and abandoned revisions.',
       ),
       'by-status' => array(
         'help' => 'Sort branches by status instead of time.',
       ),
       'output' => array(
         'param' => 'format',
         'support' => array(
           'json',
         ),
         'help' => "With 'json', show features in machine-readable JSON format.",
       ),
       '*' => 'branch',
     );
   }
 
   public function run() {
     $repository_api = $this->getRepositoryAPI();
     if (!($repository_api instanceof ArcanistGitAPI) &&
         !($repository_api instanceof ArcanistMercurialAPI)) {
       throw new ArcanistUsageException(
         'arc feature is only supported under Git and Mercurial.');
     }
 
     $names = $this->getArgument('branch');
     if ($names) {
       if (count($names) > 2) {
         throw new ArcanistUsageException('Specify only one branch.');
       }
       return $this->checkoutBranch($names);
     }
 
     $branches = $repository_api->getAllBranches();
     if (!$branches) {
       throw new ArcanistUsageException('No branches in this working copy.');
     }
 
     $branches = $this->loadCommitInfo($branches);
     $revisions = $this->loadRevisions($branches);
     $this->printBranches($branches, $revisions);
 
     return 0;
   }
 
   private function checkoutBranch(array $names) {
     $api = $this->getRepositoryAPI();
 
     if ($api instanceof ArcanistMercurialAPI) {
       $command = 'update %s';
     } else {
       $command = 'checkout %s';
     }
 
     $err = 1;
 
     $name = $names[0];
     if (isset($names[1])) {
       $start = $names[1];
     } else {
       $start = $this->getConfigFromAnySource('arc.feature.start.default');
     }
 
     $branches = $api->getAllBranches();
     if (in_array($name, ipull($branches, 'name'))) {
       list($err, $stdout, $stderr) = $api->execManualLocal($command, $name);
     }
 
     if ($err) {
       $match = null;
       if (preg_match('/^D(\d+)$/', $name, $match)) {
         try {
           $diff = $this->getConduit()->callMethodSynchronous(
             'differential.getdiff',
             array(
               'revision_id' => $match[1],
             ));
 
           if ($diff['branch'] != '') {
             $name = $diff['branch'];
             list($err, $stdout, $stderr) = $api->execManualLocal(
               $command,
               $name);
           }
         } catch (ConduitClientException $ex) {
         }
       }
     }
 
     if ($err) {
       if ($api instanceof ArcanistMercurialAPI) {
         $rev = '';
         if ($start) {
           $rev = csprintf('-r %s', $start);
         }
 
         $exec = $api->execManualLocal('bookmark %C %s', $rev, $name);
 
         if (!$exec[0] && $start) {
           $api->execxLocal('update %s', $name);
         }
       } else {
         $startarg = $start ? csprintf('%s', $start) : '';
         $exec = $api->execManualLocal(
           'checkout --track -b %s %C',
           $name,
           $startarg);
       }
 
       list($err, $stdout, $stderr) = $exec;
     }
 
     echo $stdout;
     fprintf(STDERR, $stderr);
     return $err;
   }
 
   private function loadCommitInfo(array $branches) {
     $repository_api = $this->getRepositoryAPI();
 
     $futures = array();
     foreach ($branches as $branch) {
       if ($repository_api instanceof ArcanistMercurialAPI) {
         $futures[$branch['name']] = $repository_api->execFutureLocal(
           'log -l 1 --template %s -r %s',
           "{node}\1{date|hgdate}\1{p1node}\1{desc|firstline}\1{desc}",
           hgsprintf('%s', $branch['name']));
       } else {
         // NOTE: "-s" is an option deep in git's diff argument parser that
         // doesn't seem to have much documentation and has no long form. It
         // suppresses any diff output.
         $futures[$branch['name']] = $repository_api->execFutureLocal(
           'show -s --format=%C %s --',
           '%H%x01%ct%x01%T%x01%s%x01%s%n%n%b',
           $branch['name']);
       }
     }
 
     $branches = ipull($branches, null, 'name');
 
     foreach (Futures($futures)->limit(16) as $name => $future) {
       list($info) = $future->resolvex();
       list($hash, $epoch, $tree, $desc, $text) = explode("\1", trim($info), 5);
 
       $branch = $branches[$name] + array(
         'hash' => $hash,
         'desc' => $desc,
         'tree' => $tree,
         'epoch' => (int)$epoch,
       );
 
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
         $id = $message->getRevisionID();
 
         $branch['revisionID'] = $id;
       } catch (ArcanistUsageException $ex) {
         // In case of invalid commit message which fails the parsing,
         // do nothing.
         $branch['revisionID'] = null;
       }
 
       $branches[$name] = $branch;
     }
 
     return $branches;
   }
 
   private function loadRevisions(array $branches) {
     $ids = array();
     $hashes = array();
 
     foreach ($branches as $branch) {
       if ($branch['revisionID']) {
         $ids[] = $branch['revisionID'];
       }
       $hashes[] = array('gtcm', $branch['hash']);
       $hashes[] = array('gttr', $branch['tree']);
     }
 
     $calls = array();
 
     if ($ids) {
       $calls[] = $this->getConduit()->callMethod(
         'differential.query',
         array(
           'ids' => $ids,
         ));
     }
 
     if ($hashes) {
       $calls[] = $this->getConduit()->callMethod(
         'differential.query',
         array(
           'commitHashes' => $hashes,
         ));
     }
 
     $results = array();
     foreach (Futures($calls) as $call) {
       $results[] = $call->resolve();
     }
 
     return array_mergev($results);
   }
 
   private function printBranches(array $branches, array $revisions) {
     $revisions = ipull($revisions, null, 'id');
 
     static $color_map = array(
       'Closed'          => 'cyan',
       'Needs Review'    => 'magenta',
       'Needs Revision'  => 'red',
       'Accepted'        => 'green',
       'No Revision'     => 'blue',
       'Abandoned'       => 'default',
     );
 
     static $ssort_map = array(
       'Closed'          => 1,
       'No Revision'     => 2,
       'Needs Review'    => 3,
       'Needs Revision'  => 4,
       'Accepted'        => 5,
     );
 
     $out = array();
     foreach ($branches as $branch) {
       $revision = idx($revisions, idx($branch, 'revisionID'));
 
       // If we haven't identified a revision by ID, try to identify it by hash.
       if (!$revision) {
         foreach ($revisions as $rev) {
           $hashes = idx($rev, 'hashes', array());
           foreach ($hashes as $hash) {
             if (($hash[0] == 'gtcm' && $hash[1] == $branch['hash']) ||
                 ($hash[0] == 'gttr' && $hash[1] == $branch['tree'])) {
               $revision = $rev;
               break;
             }
           }
         }
       }
 
       if ($revision) {
         $desc = 'D'.$revision['id'].': '.$revision['title'];
         $status = $revision['statusName'];
       } else {
         $desc = $branch['desc'];
         $status = 'No Revision';
       }
 
       if (!$this->getArgument('view-all') && !$branch['current']) {
         if ($status == 'Closed' || $status == 'Abandoned') {
           continue;
         }
       }
 
       $epoch = $branch['epoch'];
 
       $color = idx($color_map, $status, 'default');
       $ssort = sprintf('%d%012d', idx($ssort_map, $status, 0), $epoch);
 
       $out[] = array(
         'name'      => $branch['name'],
         'current'   => $branch['current'],
         'status'    => $status,
         'desc'      => $desc,
         'revision'  => $revision ? $revision['id'] : null,
         'color'     => $color,
         'esort'     => $epoch,
         'epoch'     => $epoch,
         'ssort'     => $ssort,
       );
     }
 
     $len_name = max(array_map('strlen', ipull($out, 'name'))) + 2;
     $len_status = max(array_map('strlen', ipull($out, 'status'))) + 2;
 
     if ($this->getArgument('by-status')) {
       $out = isort($out, 'ssort');
     } else {
       $out = isort($out, 'esort');
     }
     if ($this->getArgument('output') == 'json') {
       foreach ($out as &$feature) {
         unset($feature['color'], $feature['ssort'], $feature['esort']);
       }
       echo json_encode(ipull($out, null, 'name'))."\n";
     } else {
       $table = id(new PhutilConsoleTable())
         ->setShowHeader(false)
         ->addColumn('current', array('title' => ''))
         ->addColumn('name',    array('title' => 'Name'))
         ->addColumn('status',  array('title' => 'Status'))
         ->addColumn('descr',   array('title' => 'Description'));
 
       foreach ($out as $line) {
         $table->addRow(array(
           'current' => $line['current'] ? '*' : '',
           'name'    => phutil_console_format('**%s**', $line['name']),
           'status'  => phutil_console_format(
             "<fg:{$line['color']}>%s</fg>", $line['status']),
           'descr'   => $line['desc'],
         ));
       }
 
       $table->draw();
     }
   }
 
 }
diff --git a/src/workflow/ArcanistFlagWorkflow.php b/src/workflow/ArcanistFlagWorkflow.php
index 182ebfcf..f6d2bbd9 100644
--- a/src/workflow/ArcanistFlagWorkflow.php
+++ b/src/workflow/ArcanistFlagWorkflow.php
@@ -1,218 +1,215 @@
 <?php
 
-/**
- * @group workflow
- */
 final class ArcanistFlagWorkflow extends ArcanistBaseWorkflow {
 
   private static $colorMap = array(
     0 => 'red',     // Red
     1 => 'yellow',  // Orange
     2 => 'yellow',  // Yellow
     3 => 'green',   // Green
     4 => 'blue',    // Blue
     5 => 'magenta', // Pink
     6 => 'magenta', // Purple
     7 => 'default', // Checkered
   );
 
   private static $colorSpec = array(
     'red' => 0,       'r' => 0,   0 => 0,
     'orange' => 1,    'o' => 1,   1 => 1,
     'yellow' => 2,    'y' => 2,   2 => 2,
     'green' => 3,     'g' => 3,   3 => 3,
     'blue' => 4,      'b' => 4,   4 => 4,
     'pink' => 5,      'p' => 5,   5 => 5,
     'purple' => 6,    'v' => 6,   6 => 6,
     'checkered' => 7, 'c' => 7,   7 => 7,
   );
 
   public function getWorkflowName() {
     return 'flag';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **flag** [__object__ ...]
       **flag** __object__ --clear
       **flag** __object__ [--edit] [--color __color__] [--note __note__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           In the first form, list objects you've flagged. You can provide the
           names of one or more objects (Maniphest tasks T#\##, Differential
           revisions D###, Diffusion references rXXX???, or PHIDs PHID-XXX-???)
           to print only flags for those objects.
 
           In the second form, clear an existing flag on one object.
 
           In the third form, create or update a flag on one object. Color
           defaults to blue and note to empty, but if you omit both you must
           pass --edit.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'objects',
       'clear' => array(
-        'help' => 'Delete the flag on an object.'
+        'help' => 'Delete the flag on an object.',
       ),
       'edit' => array(
-        'help' => 'Edit the flag on an object.'
+        'help' => 'Edit the flag on an object.',
       ),
       'color' => array(
         'param' => 'color',
-        'help' => 'Set the color of a flag.'
+        'help' => 'Set the color of a flag.',
       ),
       'note' => array(
         'param' => 'note',
-        'help' => 'Set the note on a flag.'
+        'help' => 'Set the note on a flag.',
       ),
     );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   private static function flagWasEdited($flag, $verb) {
     $color = idx(self::$colorMap, $flag['color'], 'cyan');
     $note = $flag['note'];
     if ($note) {
       // Make sure notes that are long or have line breaks in them or
       // whatever don't mess up the formatting.
       $note = implode(' ', preg_split('/\s+/', $note));
       $note = ' ('.phutil_utf8_shorten($note, 40, '...').')';
     }
     echo phutil_console_format(
       "<fg:{$color}>%s</fg> flag%s $verb!\n",
       $flag['colorName'],
       $note);
   }
 
   public function run() {
     $conduit = $this->getConduit();
     $objects = $this->getArgument('objects', array());
     $phids = array();
 
     $clear = $this->getArgument('clear');
     $edit = $this->getArgument('edit');
     // I don't trust PHP to distinguish 0 (red) from null.
     $color = $this->getArgument('color', -1);
     $note = $this->getArgument('note');
     $editing = $edit || ($color != -1) || $note;
 
     if ($editing && $clear) {
       throw new ArcanistUsageException("You can't both edit and clear a flag.");
     }
     if (($editing || $clear) && count($objects) != 1) {
       throw new ArcanistUsageException('Specify exactly one object.');
     }
 
     if (!empty($objects)) {
       // First off, convert the passed objects to PHIDs.
       $handles = $conduit->callMethodSynchronous(
         'phid.lookup',
         array(
           'names' => $objects,
         ));
       foreach ($objects as $object) {
         if (isset($handles[$object])) {
           $phids[$object] = $handles[$object]['phid'];
         } else {
           echo phutil_console_format("**%s** doesn't exist.\n", $object);
         }
       }
       if (empty($phids)) {
         // flag.query treats an empty objectPHIDs parameter as "don't use this
         // constraint". However, if the user gives a list of objects but none
         // of them exist and have flags, we shouldn't dump the full list on
         // them after telling them that. Conveniently, we already told them,
         // so we can go quit now.
         return 0;
       }
     }
 
     if ($clear) {
       // All right, we're going to clear a flag. First clear it. Then tell the
       // user we cleared it. Step four: profit!
       $flag = $conduit->callMethodSynchronous(
         'flag.delete',
         array(
           'objectPHID' => head($phids),
         ));
       if (!$flag) {
         echo phutil_console_format("**%s** has no flag to clear.\n", $object);
       } else {
         self::flagWasEdited($flag, 'deleted');
       }
     } else if ($editing) {
       // Let's set some flags. Just like Minesweeper, but less distracting.
       $flag_params = array(
         'objectPHID' => head($phids),
       );
       if (isset(self::$colorSpec[$color])) {
         $flag_params['color'] = self::$colorSpec[strtolower($color)];
       }
       if ($note) {
         $flag_params['note'] = $note;
       }
       $flag = $conduit->callMethodSynchronous(
         'flag.edit',
         $flag_params);
       self::flagWasEdited($flag, $flag['new'] ? 'created' : 'edited');
     } else {
       // Okay, list mode. Let's find the flags, which we didn't need to do
       // otherwise because Conduit does it for us.
       $flags = ipull(
         $this->getConduit()->callMethodSynchronous(
           'flag.query',
           array(
             'ownerPHIDs' => array($this->getUserPHID()),
             'objectPHIDs' => array_values($phids),
           )),
         null,
         'objectPHID');
       foreach ($phids as $object => $phid) {
         if (!isset($flags[$phid])) {
           echo phutil_console_format("**%s** has no flag.\n", $object);
         }
       }
 
       if (empty($flags)) {
         // If the user passed no object names, then we should print the full
         // list, but it's empty, so tell the user they have no flags.
         // If the user passed object names, we already told them all their
         // objects are nonexistent or unflagged.
         if (empty($objects)) {
           echo "You have no flagged objects.\n";
         }
       } else {
         // Print ALL the flags. With fancy formatting. Because fancy formatting
         // is _cool_.
         $name_len = 1 + max(array_map('strlen', ipull($flags, 'colorName')));
         foreach ($flags as $flag) {
           $color = idx(self::$colorMap, $flag['color'], 'cyan');
           echo phutil_console_format(
             "[<fg:{$color}>%s</fg>] %s\n",
             str_pad($flag['colorName'], $name_len),
             $flag['handle']['fullname']);
           if ($flag['note']) {
             $note = phutil_console_wrap($flag['note'], $name_len + 3);
             echo rtrim($note)."\n";
           }
         }
       }
     }
   }
 
 }
diff --git a/src/workflow/ArcanistGitHookPreReceiveWorkflow.php b/src/workflow/ArcanistGitHookPreReceiveWorkflow.php
index 47099c10..7817cf77 100644
--- a/src/workflow/ArcanistGitHookPreReceiveWorkflow.php
+++ b/src/workflow/ArcanistGitHookPreReceiveWorkflow.php
@@ -1,122 +1,121 @@
 <?php
 
 /**
  * Installable as a git pre-receive hook.
- *
- * @group workflow
  */
 final class ArcanistGitHookPreReceiveWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'git-hook-pre-receive';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **git-hook-pre-receive**
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git
           You can install this as a git pre-receive hook.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
     );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function shouldShellComplete() {
     return false;
   }
 
   public function run() {
     $working_copy = $this->getWorkingCopy();
     if (!$working_copy->getProjectID()) {
       throw new ArcanistUsageException(
         'You have installed a git pre-receive hook in a remote without an '.
         '.arcconfig.');
     }
 
     // Git repositories have special rules in pre-receive hooks. We need to
     // construct the API against the .git directory instead of the project
     // root or commands don't work properly.
     $repository_api = ArcanistGitAPI::newHookAPI($_SERVER['PWD']);
 
     $root = $working_copy->getProjectRoot();
 
     $parser = new ArcanistDiffParser();
 
     $mark_revisions = array();
 
     $stdin = file_get_contents('php://stdin');
     $commits = array_filter(explode("\n", $stdin));
     foreach ($commits as $commit) {
       list($old_ref, $new_ref, $refname) = explode(' ', $commit);
 
       list($log) = execx(
         '(cd %s && git log -n1 %s)',
         $repository_api->getPath(),
         $new_ref);
       $message_log = reset($parser->parseDiff($log));
       $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
         $message_log->getMetadata('message'));
 
       $revision_id = $message->getRevisionID();
       if ($revision_id) {
         $mark_revisions[] = $revision_id;
       }
 
       // TODO: Do commit message junk.
 
       $info = $repository_api->getPreReceiveHookStatus($old_ref, $new_ref);
       $paths = ipull($info, 'mask');
       $frefs = ipull($info, 'ref');
       $data  = array();
       foreach ($paths as $path => $mask) {
         list($stdout) = execx(
           '(cd %s && git cat-file blob %s)',
           $repository_api->getPath(),
           $frefs[$path]);
         $data[$path] = $stdout;
       }
 
       // TODO: Do commit content junk.
 
       $commit_name = $new_ref;
       if ($revision_id) {
         $commit_name = 'D'.$revision_id.' ('.$commit_name.')';
       }
 
       echo "[arc pre-receive] {$commit_name} OK...\n";
     }
 
     $conduit = $this->getConduit();
 
     $futures = array();
     foreach ($mark_revisions as $revision_id) {
       $futures[] = $conduit->callMethod(
         'differential.close',
         array(
           'revisionID' => $revision_id,
         ));
     }
 
     Futures($futures)->resolveAll();
 
     return 0;
   }
+
 }
diff --git a/src/workflow/ArcanistHelpWorkflow.php b/src/workflow/ArcanistHelpWorkflow.php
index f489619e..fa900248 100644
--- a/src/workflow/ArcanistHelpWorkflow.php
+++ b/src/workflow/ArcanistHelpWorkflow.php
@@ -1,215 +1,213 @@
 <?php
 
 /**
  * Seduces the reader with majestic prose.
- *
- * @group workflow
  */
 final class ArcanistHelpWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'help';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **help** [__command__]
       **help** --full
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: english
           Shows this help. With __command__, shows help about a specific
           command.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'full' => array(
         'help' => 'Print detailed information about each command.',
       ),
       '*' => 'command',
     );
   }
 
   public function run() {
 
     $arc_config = $this->getArcanistConfiguration();
     $workflows = $arc_config->buildAllWorkflows();
     ksort($workflows);
 
     $target = null;
     if ($this->getArgument('command')) {
       $target = head($this->getArgument('command'));
       if (empty($workflows[$target])) {
         throw new ArcanistUsageException(
           "Unrecognized command '{$target}'. Try 'arc help'.");
       }
     }
 
     $cmdref = array();
     foreach ($workflows as $command => $workflow) {
       if ($target && $target != $command) {
         continue;
       }
       if (!$target && !$this->getArgument('full')) {
         $cmdref[] = $workflow->getCommandSynopses();
         continue;
       }
       $optref = array();
       $arguments = $workflow->getArguments();
 
       $config_arguments = $arc_config->getCustomArgumentsForCommand($command);
 
       // This juggling is to put the extension arguments after the normal
       // arguments, and make sure the normal arguments aren't overwritten.
       ksort($arguments);
       ksort($config_arguments);
       foreach ($config_arguments as $argument => $spec) {
         if (empty($arguments[$argument])) {
           $arguments[$argument] = $spec;
         }
       }
 
       foreach ($arguments as $argument => $spec) {
         if ($argument == '*') {
           continue;
         }
         if (!empty($spec['hide'])) {
           continue;
         }
         if (isset($spec['param'])) {
           if (isset($spec['short'])) {
             $optref[] = phutil_console_format(
               '          __--%s__ __%s__, __-%s__ __%s__',
               $argument,
               $spec['param'],
               $spec['short'],
               $spec['param']);
           } else {
             $optref[] = phutil_console_format(
               '          __--%s__ __%s__',
               $argument,
               $spec['param']);
           }
         } else {
           if (isset($spec['short'])) {
             $optref[] = phutil_console_format(
               '          __--%s__, __-%s__',
               $argument,
               $spec['short']);
           } else {
             $optref[] = phutil_console_format(
               '          __--%s__',
               $argument);
           }
         }
 
         if (isset($config_arguments[$argument])) {
           $optref[] = '              (This is a custom option for this '.
                       'project.)';
         }
 
         if (isset($spec['supports'])) {
           $optref[] = '              Supports: '.
                       implode(', ', $spec['supports']);
         }
 
         if (isset($spec['help'])) {
           $docs = $spec['help'];
         } else {
           $docs = 'This option is not documented.';
         }
         $docs = phutil_console_wrap($docs, 14);
         $optref[] = "{$docs}\n";
       }
       if ($optref) {
         $optref = implode("\n", $optref);
         $optref = "\n\n".$optref;
       } else {
         $optref = "\n";
       }
 
       $cmdref[] =
         $workflow->getCommandSynopses()."\n".
         $workflow->getCommandHelp().
         $optref;
     }
     $cmdref = implode("\n\n", $cmdref);
 
     if ($target) {
       echo "\n".$cmdref."\n";
       return;
     }
 
     $self = 'arc';
     echo phutil_console_format(<<<EOTEXT
 **NAME**
       **{$self}** - arcanist, a code review and revision management utility
 
 **SYNOPSIS**
       **{$self}** __command__ [__options__] [__args__]
       This help file provides a detailed command reference.
 
 **COMMAND REFERENCE**
 
 {$cmdref}
 
 
 EOTEXT
     );
 
     if (!$this->getArgument('full')) {
       echo "Run 'arc help --full' to get commands and options descriptions.\n";
       return;
     }
 
     echo phutil_console_format(<<<EOTEXT
 **OPTION REFERENCE**
 
       __--trace__
           Debugging command. Shows underlying commands as they are executed,
           and full stack traces when exceptions are thrown.
 
       __--no-ansi__
           Output in plain ASCII text only, without color or style.
 
       __--ansi__
           Use formatting even in environments which probably don't support it.
           Example: arc --ansi unit | less -r
 
       __--load-phutil-library=/path/to/library__
           Ignore libraries listed in .arcconfig and explicitly load specified
           libraries instead. Mostly useful for Arcanist development.
 
       __--conduit-uri__ __uri__
           Ignore configured Conduit URI and use an explicit one instead. Mostly
           useful for Arcanist development.
 
       __--conduit-version__ __version__
           Ignore software version and claim to be running some other version
           instead. Mostly useful for Arcanist development. May cause bad things
           to happen.
 
       __--conduit-timeout__ __timeout__
           Override the default Conduit timeout. Specified in seconds.
 
       __--config__ __key=value__
           Specify a runtime configuration value. This will take precedence
           over static values, and only affect the current arcanist invocation.
 
       __--skip-arcconfig__
           Skip the working copy configuration file
 
       __--arcrc-file__ __filename__
           Use provided file instead of ~/.arcrc.
 
 EOTEXT
     );
   }
 }
diff --git a/src/workflow/ArcanistInlinesWorkflow.php b/src/workflow/ArcanistInlinesWorkflow.php
index 2bcd08e6..6435f8d2 100644
--- a/src/workflow/ArcanistInlinesWorkflow.php
+++ b/src/workflow/ArcanistInlinesWorkflow.php
@@ -1,105 +1,103 @@
 <?php
 
-/**
- * @group workflow
- */
 final class ArcanistInlinesWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'inlines';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **inlines** [--revision __revision_id__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Display inline comments related to a particular revision.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'revision' => array(
         'param' => 'revision_id',
         'help' =>
           'Display inline comments for a specific revision. If you do not '.
           'specify a revision, arc will look in the commit message at HEAD.',
       ),
       'root' => array(
         'param' => 'directory',
         'help' => 'Specify a string printed in front of each path.',
       ),
     );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function run() {
     if ($this->getArgument('revision')) {
       $revision_id = $this->normalizeRevisionID($this->getArgument('revision'));
     } else {
       $revisions = $this->getRepositoryAPI()
         ->loadWorkingCopyDifferentialRevisions($this->getConduit(), array());
       $revision_id = head(ipull($revisions, 'id'));
     }
 
     if (!$revision_id) {
       throw new ArcanistUsageException('No revisions found.');
     }
 
     $comments = array_mergev(
       $this->getConduit()->callMethodSynchronous(
         'differential.getrevisioncomments',
         array(
           'ids' => array($revision_id),
           'inlines' => true,
         )));
 
     $authors = array();
     if ($comments) {
       $authors = $this->getConduit()->callMethodSynchronous(
         'user.query',
         array(
           'phids' => array_unique(ipull($comments, 'authorPHID')),
         ));
       $authors = ipull($authors, 'userName', 'phid');
     }
 
     $inlines = array();
     foreach ($comments as $comment) {
       $author = idx($authors, $comment['authorPHID']);
       foreach ($comment['inlines'] as $inline) {
         $file = $inline['filePath'];
         $line = $inline['lineNumber'];
         $inlines[$file][$line][] = "({$author}) {$inline['content']}";
       }
     }
 
     $root = $this->getArgument('root');
     ksort($inlines);
     foreach ($inlines as $file => $file_inlines) {
       ksort($file_inlines);
       foreach ($file_inlines as $line => $line_inlines) {
         foreach ($line_inlines as $content) {
           echo "{$root}{$file}:{$line}:{$content}\n";
         }
       }
     }
   }
+
 }
diff --git a/src/workflow/ArcanistInstallCertificateWorkflow.php b/src/workflow/ArcanistInstallCertificateWorkflow.php
index d92941e2..49acd959 100644
--- a/src/workflow/ArcanistInstallCertificateWorkflow.php
+++ b/src/workflow/ArcanistInstallCertificateWorkflow.php
@@ -1,140 +1,137 @@
 <?php
 
 /**
  * Installs arcanist certificates.
- *
- * @group workflow
  */
 final class ArcanistInstallCertificateWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'install-certificate';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **install-certificate** [uri]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: http, https
           Installs Conduit credentials into your ~/.arcrc for the given install
           of Phabricator. You need to do this before you can use 'arc', as it
           enables 'arc' to link your command-line activity with your account on
           the web. Run this command from within a project directory to install
           that project's certificate, or specify an explicit URI (like
           "https://phabricator.example.com/").
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'uri',
     );
   }
 
   public function shouldShellComplete() {
     return false;
   }
 
   public function requiresConduit() {
     return false;
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
   public function run() {
-
     $uri = $this->determineConduitURI();
     $this->setConduitURI($uri);
     $configuration_manager = $this->getConfigurationManager();
 
     echo "Installing certificate for '{$uri}'...\n";
 
     $config = $configuration_manager->readUserConfigurationFile();
 
     echo "Trying to connect to server...\n";
     $conduit = $this->establishConduit()->getConduit();
     try {
       $conduit->callMethodSynchronous('conduit.ping', array());
     } catch (Exception $ex) {
       throw new ArcanistUsageException(
         'Failed to connect to server: '.$ex->getMessage());
     }
     echo "Connection OK!\n";
 
     $token_uri = new PhutilURI($uri);
     $token_uri->setPath('/conduit/token/');
 
     echo "\n";
     echo phutil_console_format("**LOGIN TO PHABRICATOR**\n");
     echo "Open this page in your browser and login to Phabricator if ".
          "necessary:\n";
     echo "\n";
     echo "    {$token_uri}\n";
     echo "\n";
     echo 'Then paste the token on that page below.';
 
 
     do {
       $token = phutil_console_prompt('Paste token from that page:');
       $token = trim($token);
       if (strlen($token)) {
         break;
       }
     } while (true);
 
     echo "\n";
     echo "Downloading authentication certificate...\n";
     $info = $conduit->callMethodSynchronous(
       'conduit.getcertificate',
       array(
         'token' => $token,
         'host'  => $uri,
       ));
 
     $user = $info['username'];
     echo "Installing certificate for '{$user}'...\n";
     $config['hosts'][$uri] = array(
       'user' => $user,
       'cert' => $info['certificate'],
     );
 
     echo "Writing ~/.arcrc...\n";
     $configuration_manager->writeUserConfigurationFile($config);
 
     echo phutil_console_format(
       "<bg:green>** SUCCESS! **</bg> Certificate installed.\n");
 
     return 0;
   }
 
   private function determineConduitURI() {
     $uri = $this->getArgument('uri');
     if (count($uri) > 1) {
       throw new ArcanistUsageException('Specify at most one URI.');
     } else if (count($uri) == 1) {
       $uri = reset($uri);
     } else {
       $conduit_uri = $this->getConduitURI();
       if (!$conduit_uri) {
         throw new ArcanistUsageException(
           'Specify an explicit URI or run this command from within a project '.
           'which is configured with a .arcconfig.');
       }
       $uri = $conduit_uri;
     }
 
     $uri = new PhutilURI($uri);
     $uri->setPath('/api/');
 
     return (string)$uri;
   }
 
 }
diff --git a/src/workflow/ArcanistLandWorkflow.php b/src/workflow/ArcanistLandWorkflow.php
index 6b3fe8cf..6ed5c001 100644
--- a/src/workflow/ArcanistLandWorkflow.php
+++ b/src/workflow/ArcanistLandWorkflow.php
@@ -1,1265 +1,1271 @@
 <?php
 
 /**
  * Lands a branch by rebasing, merging and amending it.
- *
- * @group workflow
  */
 final class ArcanistLandWorkflow extends ArcanistBaseWorkflow {
+
   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;
 
   public function getRevisionDict() {
     return $this->revision;
   }
 
   public function getWorkflowName() {
     return 'land';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **land** [__options__] [__branch__] [--onto __master__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg
 
           Land an accepted change (currently sitting in local feature branch
           __branch__) onto __master__ and push it to the remote. Then, delete
           the feature branch. If you omit __branch__, the current branch will
           be used.
 
           In mutable repositories, this will perform a --squash merge (the
           entire branch will be represented by one commit on __master__). In
           immutable repositories (or when --merge is provided), it will perform
           a --no-ff merge (the branch will always be merged into __master__ with
           a merge commit).
 
           Under hg, bookmarks can be landed the same way as branches.
 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 '.
-                      '\'arc.land.onto.default\' with `arc set-config` or '.
-                      'for the entire project in .arcconfig.'),
+        '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 'arc.land.onto.default' with `arc set-config` or ".
+          "for the entire project in .arcconfig."),
       ),
       'hold' => array(
-        'help' => pht('Prepare the change to be pushed, but do not actually '.
-                      'push it.'),
+        '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).'),
+        '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).'),
+        'help' => pht(
+          "Push to a remote other than the default ('origin' in git)."),
       ),
       'merge' => array(
-        'help' => pht('Perform a --no-ff merge, not a --squash merge. If the '.
-                      'project is marked as having an immutable history, '.
-                      'this is the default behavior.'),
+        'help' => pht(
+          'Perform a --no-ff merge, not a --squash merge. If the project '.
+          'is marked as having an immutable history, this is the default '.
+          'behavior.'),
         'supports' => array(
           'git',
         ),
         'nosupport'   => array(
           'hg' => pht('Use the --squash strategy when landing in mercurial.'),
         ),
       ),
       'squash' => array(
-        'help' => pht('Perform a --squash merge, not a --no-ff merge. If the '.
-                      'project is marked as having a mutable history, this '.
-                      'is the default behavior.'),
+        'help' => pht(
+          'Perform a --squash merge, not a --no-ff merge. If the project is '.
+          'marked as having a mutable history, this is the default behavior.'),
         'conflicts' => array(
           'merge' => '--merge and --squash are conflicting merge strategies.',
         ),
       ),
       'delete-remote' => array(
-        'help'      => pht('Delete the feature branch in the remote after '.
-                           'landing it.'),
+        '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 arc.land.update.default '.
-                         'to \'rebase\' to make this the default.'),
+        'help' => pht(
+          "When updating the feature branch, use rebase instead of merge. ".
+          "This might make things work better in some cases. Set ".
+          "arc.land.update.default to 'rebase' to make this the default."),
         'conflicts' => array(
-          'merge' => pht('The --merge strategy does not update the feature '.
-                         'branch.'),
-          'update-with-merge' => pht('Cannot be used with '.
-                                     '--update-with-merge.'),
+          'merge' => pht(
+            'The --merge strategy does not update the feature branch.'),
+          'update-with-merge' => pht(
+            'Cannot be used with --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 '.
-                         'arc.land.update.default to \'merge\' can also be '.
-                         'used to make this the default.'),
+        'help' => pht(
+          "When updating the feature branch, use merge instead of rebase. ".
+          "This is the default behavior. Setting arc.land.update.default to ".
+          "'merge' can also be used to make this the default."),
         'conflicts' => array(
-          'merge' => pht('The --merge strategy does not update the feature '.
-                         'branch.'),
-          'update-with-rebase' => pht('Cannot be used with '.
-                                      '--update-with-rebase.'),
+          'merge' => pht(
+            'The --merge strategy does not update the feature branch.'),
+          'update-with-rebase' => pht(
+            'Cannot be used with --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.'),
+        '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.'),
+        'help' => pht(
+          'Prints the commits that would be landed. Does not '.
+          'actually modify or land the commits.'),
       ),
       '*' => 'branch',
     );
   }
 
   public function run() {
     $this->readArguments();
     $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 readArguments() {
     $repository_api = $this->getRepositoryAPI();
     $this->isGit = $repository_api instanceof ArcanistGitAPI;
     $this->isHg = $repository_api instanceof ArcanistMercurialAPI;
 
     if (!$this->isGit && !$this->isHg) {
       throw new ArcanistUsageException(
         pht("'arc land' only supports git and mercurial."));
     }
 
     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);
         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');
     $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);
     $this->onto = $this->getArgument('onto', $onto_default);
     $this->ontoType = $this->getBranchType($this->onto);
 
     $remote_default = $this->isGit ? 'origin' : '';
     $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 'arc amend' instead.");
       }
       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 --squash '.
-                'strategy.'));
+            pht(
+              'You must enable the rebase extension to use the --squash '.
+              'strategy.'));
         }
       }
 
       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 --onto to specify a %s, '.
           'or set arc.land.onto.default in .arcconfig.',
           $this->branch,
           $this->branchType,
           $this->onto,
           $this->ontoType,
           $this->branchType,
           $this->branchType,
           $this->branchType));
       }
     }
 
     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);
     }
 
     echo phutil_console_format(
       pht('Switched to %s **%s**. Identifying and merging...',
           $this->branchType,
           $this->branch).
       "\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 'arc amend' to amend the commit message at HEAD, or use ".
         "'--revision <id>' to select a revision explicitly.",
         $this->branchType,
         $this->branch,
         $this->branchType));
     } else if (count($revisions) > 1) {
       $message = pht(
         "There are multiple revisions on feature %s '%s' which are not ".
         "present on '%s':\n\n".
         "%s\n".
         "Separate these revisions onto different %s, or use --revision <id>' ".
         "to use the commit message from <id> and land them all.",
         $this->branchType,
         $this->branch,
         $this->onto,
         $this->renderRevisionList($revisions),
         $this->branchType.'s');
       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 ".
             "'arc land' again.",
             $this->onto,
             $this->onto,
             $divergedbookmark)));
         }
       } 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
+      // 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 'arc land'.",
         $this->ontoType,
         $this->onto,
         $this->ontoType,
         $this->ontoRemoteBranch,
         $this->ontoType,
         $this->onto));
     }
   }
 
   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(
             "'git rebase %s' failed. You can abort with 'git rebase ".
             "--abort', or resolve conflicts and use 'git rebase --continue' ".
             "to continue forward. After resolving the rebase, run 'arc land' ".
             "again.",
             $this->onto));
         }
       } 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 'arc land'"));
         if ($err) {
           throw new ArcanistUsageException(pht(
             "'git merge %s' failed. ".
             "To continue: resolve the conflicts, commit the changes, then run ".
             "'arc land' again. To abort: run 'git merge --abort'.",
             $this->onto));
         }
       }
     } 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("Aborting rebase\n");
           $repository_api->execManualLocal(
             'rebase --abort');
           $this->restoreBranch();
           throw new ArcanistUsageException(pht(
             "'hg rebase %s' failed and the rebase was aborted. ".
             "This is most likely due to conflicts. Manually rebase %s onto ".
             "%s, resolve the conflicts, then run 'arc land' again.",
             $this->onto,
             $this->branch,
             $this->onto));
         }
       }
     }
 
     $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(
           "Squashing the commits under {$this->branch} failed. ".
           "Manually squash your commits and run 'arc land' again.");
       }
 
       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 arc land again:\n%s",
               $this->branchType.'s',
               $branch_string),
           "\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(
           "'git merge' failed. Your working copy has been left in a partially ".
           "merged state. You can: abort with 'git merge --abort'; or follow ".
           "the instructions to complete the merge."));
       }
     } 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(
         '--merge is not currently supported for hg repos.'));
     }
   }
 
   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.
+          // 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->dispatchEvent(
         ArcanistEventType::TYPE_LAND_WILLPUSHREVISION,
         array());
     } 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) {
         $err = $repository_api->execPassthru(
           'push -r %s %s',
           $this->onto,
           $this->remote);
         $cmd = 'hg push';
       }
 
       if ($err) {
         $failed_str = pht('PUSH FAILED!');
         echo phutil_console_format("<bg:red>**   %s   **</bg>\n", $failed_str);
         $this->executeCleanupAfterFailedPush();
         if ($this->isGit) {
           throw new ArcanistUsageException(pht(
             "'%s' failed! Fix the error and run 'arc land' again.",
             $cmd));
         }
         throw new ArcanistUsageException(pht(
           "'%s' failed! Fix the error and push this change manually.",
           $cmd));
       }
 
       // 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->getRepositoryCallsign()) {
         try {
           $this->getConduit()->callMethodSynchronous(
             'diffusion.looksoon',
             array(
               'callsigns' => array($this->getRepositoryCallsign()),
             ));
         } 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.
         }
       }
 
       $mark_workflow = $this->buildChildWorkflow(
         'close-revision',
         array(
           '--finalize',
           '--quiet',
           $this->revision['id'],
         ));
       $mark_workflow->run();
 
       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), "\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);
         }
       }
     }
   }
 
   protected function getSupportedRevisionControlSystems() {
     return array('git', 'hg');
   }
 
   private function getBranchOrBookmark() {
     $repository_api = $this->getRepositoryAPI();
     if ($this->isGit) {
       $branch = $repository_api->getBranchName();
     } 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 phutil_console_format(
       "Switched back to {$this->branchType} **%s**.\n",
       $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();
     }
   }
 
 }
diff --git a/src/workflow/ArcanistLiberateWorkflow.php b/src/workflow/ArcanistLiberateWorkflow.php
index a9cccced..b02a649b 100644
--- a/src/workflow/ArcanistLiberateWorkflow.php
+++ b/src/workflow/ArcanistLiberateWorkflow.php
@@ -1,241 +1,239 @@
 <?php
 
 /**
  * Create and update libphutil libraries.
  *
- * This workflow is unusual and involves reexecuting 'arc liberate' as a
- * subprocess with "--remap" and "--verify". This is because there is no way
+ * This workflow is unusual and involves re-executing 'arc liberate' as a
+ * subprocess with `--remap` and `--verify`. This is because there is no way
  * to unload or reload a library, so every process is stuck with the library
  * definition it had when it first loaded. This is normally fine, but
- * problematic in this case because 'arc liberate' modifies library definitions.
- *
- * @group workflow
+ * problematic in this case because `arc liberate` modifies library definitions.
  */
 final class ArcanistLiberateWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'liberate';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **liberate** [__path__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: libphutil
           Create or update a libphutil library, generating required metadata
           files like \__init__.php.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'all' => array(
         'help' =>
           'Drop the module cache before liberating. This will completely '.
           'reanalyze the entire library. Thorough, but slow!',
       ),
       'force-update' => array(
         'help' =>
           'Force the library map to be updated, even in the presence of '.
           'lint errors.',
       ),
       'library-name' => array(
         'param' => 'name',
         'help' =>
           'Use a flag for library name rather than awaiting user input.',
       ),
       'remap' => array(
         'hide' => true,
         'help' =>
           'Internal. Run the remap step of liberation. You do not need to '.
           'run this unless you are debugging the workflow.',
       ),
       'verify' => array(
         'hide' => true,
         'help' =>
           'Internal. Run the verify step of liberation. You do not need to '.
           'run this unless you are debugging the workflow.',
       ),
       'upgrade' => array(
         'hide'  => true,
         'help'  => 'Experimental. Upgrade library to v2.',
       ),
       '*' => 'argv',
     );
   }
 
   public function run() {
     $argv = $this->getArgument('argv');
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         "Provide only one path to 'arc liberate'. The path should be a ".
         "directory where you want to create or update a libphutil library.");
     } else if (count($argv) == 0) {
       $path = getcwd();
     } else {
       $path = reset($argv);
     }
 
     $is_remap = $this->getArgument('remap');
     $is_verify = $this->getArgument('verify');
 
     $path = Filesystem::resolvePath($path);
 
     if (Filesystem::pathExists($path) && is_dir($path)) {
       $init = id(new FileFinder($path))
         ->withPath('*/__phutil_library_init__.php')
         ->find();
     } else {
       $init = null;
     }
 
     if ($init) {
       if (count($init) > 1) {
         throw new ArcanistUsageException(
           'Specified directory contains more than one libphutil library. Use '.
           'a more specific path.');
       }
       $path = Filesystem::resolvePath(dirname(reset($init)), $path);
     } else {
       $found = false;
       foreach (Filesystem::walkToRoot($path) as $dir) {
         if (Filesystem::pathExists($dir.'/__phutil_library_init__.php')) {
           $path = $dir;
           $found = true;
           break;
         }
       }
       if (!$found) {
         echo "No library currently exists at that path...\n";
         $this->liberateCreateDirectory($path);
         $this->liberateCreateLibrary($path);
         return;
       }
     }
 
     $version = $this->getLibraryFormatVersion($path);
     switch ($version) {
       case 1:
         if ($this->getArgument('upgrade')) {
           return $this->upgradeLibrary($path);
         }
         throw new ArcanistUsageException(
           "This library is using libphutil v1, which is no longer supported. ".
           "Run 'arc liberate --upgrade' to upgrade to v2.");
       case 2:
         if ($this->getArgument('upgrade')) {
           throw new ArcanistUsageException(
             "Can't upgrade a v2 library!");
         }
         return $this->liberateVersion2($path);
       default:
         throw new ArcanistUsageException(
           "Unknown library version '{$version}'!");
     }
   }
 
   private function getLibraryFormatVersion($path) {
     $map_file = $path.'/__phutil_library_map__.php';
     if (!Filesystem::pathExists($map_file)) {
       // Default to library v1.
       return 1;
     }
 
     $map = Filesystem::readFile($map_file);
 
     $matches = null;
     if (preg_match('/@phutil-library-version (\d+)/', $map, $matches)) {
       return (int)$matches[1];
     }
 
     return 1;
   }
 
   private function liberateVersion2($path) {
     $bin = $this->getScriptPath('scripts/phutil_rebuild_map.php');
 
     return phutil_passthru(
       'php %s %C %s',
       $bin,
       $this->getArgument('all') ? '--drop-cache' : '',
       $path);
   }
 
   private function upgradeLibrary($path) {
     $inits = id(new FileFinder($path))
       ->withPath('*/__init__.php')
       ->withType('f')
       ->find();
 
     echo "Removing __init__.php files...\n";
     foreach ($inits as $init) {
       Filesystem::remove($path.'/'.$init);
     }
 
     echo "Upgrading library to v2...\n";
     $this->liberateVersion2($path);
   }
 
   private function liberateCreateDirectory($path) {
     if (Filesystem::pathExists($path)) {
       if (!is_dir($path)) {
         throw new ArcanistUsageException(
           'Provide a directory to create or update a libphutil library in.');
       }
       return;
     }
 
     echo "The directory '{$path}' does not exist.";
     if (!phutil_console_confirm('Do you want to create it?')) {
       throw new ArcanistUsageException('Cancelled.');
     }
 
     execx('mkdir -p %s', $path);
   }
 
   private function liberateCreateLibrary($path) {
     $init_path = $path.'/__phutil_library_init__.php';
     if (Filesystem::pathExists($init_path)) {
       return;
     }
 
     echo "Creating new libphutil library in '{$path}'.\n";
 
     do {
       $name = $this->getArgument('library-name');
       if ($name === null) {
         echo "Choose a name for the new library.\n";
         $name = phutil_console_prompt('What do you want to name this library?');
       } else {
         echo "Using library name {$name}.\n";
       }
       if (preg_match('/^[a-z-]+$/', $name)) {
         break;
       } else {
         echo "Library name should contain only lowercase letters and ".
           "hyphens.\n";
       }
     } while (true);
 
     $template =
       "<?php\n\n".
       "phutil_register_library('{$name}', __FILE__);\n";
 
     echo "Writing '__phutil_library_init__.php' to '{$path}'...\n";
     Filesystem::writeFile($init_path, $template);
     $this->liberateVersion2($path);
   }
 
 
   private function getScriptPath($script) {
     $root = dirname(phutil_get_library_root('phutil'));
     return $root.'/'.$script;
   }
 
 }
diff --git a/src/workflow/ArcanistLintWorkflow.php b/src/workflow/ArcanistLintWorkflow.php
index 96943d85..0a8d941e 100644
--- a/src/workflow/ArcanistLintWorkflow.php
+++ b/src/workflow/ArcanistLintWorkflow.php
@@ -1,638 +1,636 @@
 <?php
 
 /**
  * Runs lint rules on changes.
- *
- * @group workflow
  */
 final class ArcanistLintWorkflow extends ArcanistBaseWorkflow {
 
   const RESULT_OKAY       = 0;
   const RESULT_WARNINGS   = 1;
   const RESULT_ERRORS     = 2;
   const RESULT_SKIP       = 3;
   const RESULT_POSTPONED  = 4;
 
   const DEFAULT_SEVERITY = ArcanistLintSeverity::SEVERITY_ADVICE;
 
   private $unresolvedMessages;
   private $shouldLintAll;
   private $shouldAmendChanges = false;
   private $shouldAmendWithoutPrompt = false;
   private $shouldAmendAutofixesWithoutPrompt = false;
   private $engine;
   private $postponedLinters;
 
   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' =>
-        'Show all lint warnings, not just those on changed lines.  When '.
+        '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' =>
-        'Show lint warnings just on changed lines.  When no paths are '.
-        'specified, this is the default.  This differs from only-new '.
+        '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' => 'Lint changes since a specific revision.',
         'supports' => array(
           'git',
           'hg',
         ),
         'nosupport' => array(
           'svn' => 'Lint does not currently support --rev in SVN.',
         ),
       ),
       'output' => array(
         'param' => 'format',
         'help' =>
           "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."
       ),
       'only-new' => array(
         'param' => 'bool',
         'supports' => array('git', 'hg'), // TODO: svn
         'help' => 'Display only messages not present in the original code.',
       ),
       'engine' => array(
         'param' => 'classname',
         'help' =>
           'Override configured lint engine for this project.'
       ),
       'apply-patches' => array(
         'help' =>
           'Apply patches suggested by lint to the working copy without '.
           'prompting.',
         'conflicts' => array(
           'never-apply-patches' => true,
         ),
       ),
       'never-apply-patches' => array(
         'help' => 'Never apply patches suggested by lint.',
         'conflicts' => array(
           'apply-patches' => true,
         ),
       ),
       'amend-all' => array(
         'help' =>
         'When linting git repositories, amend HEAD with all patches '.
         'suggested by lint without prompting.',
       ),
       'amend-autofixes' => array(
         'help' =>
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.',
       ),
       'everything' => array(
         'help' => 'Lint all files in the project.',
         'conflicts' => array(
           'cache' => '--everything lints all files',
           'rev' => '--everything lints all files'
         ),
       ),
       'severity' => array(
         'param' => 'string',
         'help' =>
           "Set minimum message severity. One of: '".
           implode(
             "', '",
             array_keys(ArcanistLintSeverity::getLintSeverities())).
           "'. Defaults to '".self::DEFAULT_SEVERITY."'.",
       ),
       'cache' => array(
         'param' => 'bool',
         'help' =>
           "0 to disable cache, 1 to enable. The default value is ".
           "determined by 'arc.lint.cache' in configuration, which defaults ".
           "to off. See notes in '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(
         'You can not specify paths with --everything. The --everything '.
         'flag lints every file.');
     }
     if ($use_cache === null) {
       $use_cache = (bool)$configuration_manager->getConfigFromAnySource(
         'arc.lint.cache',
         false);
     }
 
     if ($rev && $paths) {
       throw new ArcanistUsageException('Specify either --rev or paths.');
     }
 
 
     // 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());
       $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(
           pht("Using lint cache, use '--cache 0' to disable it.")."\n");
       }
 
       $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(
         'arcanistProject' => $this->getWorkingCopy()->getProjectID(),
         '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();
         }
       }
     }
 
     // It'd be nice to just return a single result from the run method above
     // which contains both the lint messages and the postponed linters.
     // However, to maintain compatibility with existing lint subclasses, use
     // a separate method call to grab the postponed linters.
     $this->postponedLinters = $engine->getPostponedLinters();
 
     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 ArcanistLintJSONRenderer();
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         break;
       case 'summary':
         $renderer = new ArcanistLintSummaryRenderer();
         break;
       case 'none':
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         $renderer = new ArcanistLintNoneRenderer();
         break;
       case 'compiler':
         $renderer = new ArcanistLintLikeCompilerRenderer();
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         break;
       case 'xml':
         $renderer = new ArcanistLintCheckstyleXMLRenderer();
         $prompt_patches = false;
         $apply_patches = $this->getArgument('apply-patches');
         break;
       default:
         $renderer = new ArcanistLintConsoleRenderer();
         $renderer->setShowAutofixPatches($prompt_autofix_patches);
         break;
     }
 
     $all_autofix = true;
     $console->writeOut('%s', $renderer->renderPreamble());
 
     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) {
         $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 = phutil_console_format(
             'Apply this patch to __%s__?',
             $result->getPath());
           if (!$console->confirm($prompt, $default_no = false)) {
             continue;
           }
         }
 
         $patcher->writePatchToDisk();
         $wrote_to_disk = true;
         $file_hashes[$old_file] = md5_file($old_file);
       }
     }
 
     $console->writeOut('%s', $renderer->renderPostamble());
 
     if ($wrote_to_disk && $this->shouldAmendChanges) {
       if ($this->shouldAmendWithoutPrompt ||
           ($this->shouldAmendAutofixesWithoutPrompt && $all_autofix)) {
         $console->writeOut(
           "<bg:yellow>** LINT NOTICE **</bg> Automatically amending HEAD ".
           "with lint patches.\n");
         $amend = true;
       } else {
         $amend = $console->confirm('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(
           '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 ArcanistLintNoneRenderer) {
           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 if (!empty($this->postponedLinters)) {
       $result_code = self::RESULT_POSTPONED;
     } 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;
   }
 
   public function getPostponedLinters() {
     return $this->postponedLinters;
   }
 
 }
diff --git a/src/workflow/ArcanistListWorkflow.php b/src/workflow/ArcanistListWorkflow.php
index e443e700..d3c2a3c8 100644
--- a/src/workflow/ArcanistListWorkflow.php
+++ b/src/workflow/ArcanistListWorkflow.php
@@ -1,107 +1,106 @@
 <?php
 
 /**
  * Lists open revisions in Differential.
- *
- * @group workflow
  */
 final class ArcanistListWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'list';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **list**
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           List your open Differential revisions.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function run() {
     static $color_map = array(
       'Closed'          => 'cyan',
       'Needs Review'    => 'magenta',
       'Needs Revision'  => 'red',
       'Changes Planned' => 'red',
       'Accepted'        => 'green',
       'No Revision'     => 'blue',
       'Abandoned'       => 'default',
     );
 
     $revisions = $this->getConduit()->callMethodSynchronous(
       'differential.query',
       array(
         'authors' => array($this->getUserPHID()),
         'status'  => 'status-open',
       ));
 
     if (!$revisions) {
       echo "You have no open Differential revisions.\n";
       return 0;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $info = array();
     foreach ($revisions as $key => $revision) {
       $revision_path = Filesystem::resolvePath($revision['sourcePath']);
       $current_path  = Filesystem::resolvePath($repository_api->getPath());
       if ($revision_path == $current_path) {
         $info[$key]['exists'] = 1;
       } else {
         $info[$key]['exists'] = 0;
       }
       $info[$key]['sort'] = sprintf(
         '%d%04d%08d',
         $info[$key]['exists'],
         $revision['status'],
         $revision['id']);
       $info[$key]['statusName'] = $revision['statusName'];
       $info[$key]['color'] = idx(
         $color_map, $revision['statusName'], 'default');
     }
 
     $table = id(new PhutilConsoleTable())
       ->setShowHeader(false)
       ->addColumn('exists', array('title' => ''))
       ->addColumn('status', array('title' => 'Status'))
       ->addColumn('title',  array('title' => 'Title'));
 
     $info = isort($info, 'sort');
     foreach ($info as $key => $spec) {
       $revision = $revisions[$key];
 
       $table->addRow(array(
         'exists' => $spec['exists'] ? phutil_console_format('**%s**', '*') : '',
         'status' => phutil_console_format(
           "<fg:{$spec['color']}>%s</fg>", $spec['statusName']),
         'title'  => phutil_console_format(
           '**D%d:** %s', $revision['id'], $revision['title']),
       ));
     }
 
     $table->draw();
     return 0;
   }
+
 }
diff --git a/src/workflow/ArcanistPasteWorkflow.php b/src/workflow/ArcanistPasteWorkflow.php
index 373f89a0..f85fc39b 100644
--- a/src/workflow/ArcanistPasteWorkflow.php
+++ b/src/workflow/ArcanistPasteWorkflow.php
@@ -1,153 +1,151 @@
 <?php
 
 /**
  * Upload a chunk of text to the Paste application, or download one.
- *
- * @group workflow
  */
 final class ArcanistPasteWorkflow extends ArcanistBaseWorkflow {
 
   private $id;
   private $language;
   private $title;
   private $json;
 
   public function getWorkflowName() {
     return 'paste';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **paste** [--title __title__] [--lang __language__] [--json]
       **paste** __id__ [--json]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: text
           Share and grab text using the Paste application. To create a paste,
           use stdin to provide the text:
 
             $ cat list_of_ducks.txt | arc paste
 
           To retrieve a paste, specify the paste ID:
 
             $ arc paste P123
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'title' => array(
         'param' => 'title',
         'help' => 'Title for the paste.',
       ),
       'lang' => array(
         'param' => 'language',
         'help' => 'Language for syntax highlighting.',
       ),
       'json' => array(
         'help' => 'Output in JSON format.',
       ),
       '*' => 'argv',
     );
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   protected function didParseArguments() {
     $this->language = $this->getArgument('lang');
     $this->title    = $this->getArgument('title');
     $this->json     = $this->getArgument('json');
 
     $argv = $this->getArgument('argv');
     if (count($argv) > 1) {
       throw new ArcanistUsageException('Specify only one paste to retrieve.');
     } else if (count($argv) == 1) {
       $id = $argv[0];
       if (!preg_match('/^P?\d+/', $id)) {
         throw new ArcanistUsageException('Specify a paste ID, like P123.');
       }
       $this->id = (int)ltrim($id, 'P');
 
       if ($this->language || $this->title) {
         throw new ArcanistUsageException(
           'Use options --lang and --title only when creating pastes.');
       }
     }
   }
 
   private function getTitle() {
     return $this->title;
   }
 
   private function getLanguage() {
     return $this->language;
   }
 
   private function getJSON() {
     return $this->json;
   }
 
   public function run() {
 
     if ($this->id) {
       return $this->getPaste();
     } else {
       return $this->createPaste();
     }
   }
 
   private function getPaste() {
     $conduit = $this->getConduit();
 
     $info = $conduit->callMethodSynchronous(
       'paste.query',
       array(
         'ids' => array($this->id),
       ));
     $info = head($info);
 
     if ($this->getJSON()) {
       echo json_encode($info)."\n";
     } else {
       echo $info['content'];
       if (!preg_match('/\\n$/', $info['content'])) {
         // If there's no newline, add one, since it looks stupid otherwise. If
         // you want byte-for-byte equivalence you can use --json.
         echo "\n";
       }
     }
 
     return 0;
   }
 
   private function createPaste() {
     $conduit = $this->getConduit();
 
     // Avoid confusion when people type "arc paste" with nothing else.
     $this->writeStatusMessage("Reading paste from stdin...\n");
 
     $info = $conduit->callMethodSynchronous(
       'paste.create',
       array(
         'content'   => file_get_contents('php://stdin'),
         'title'     => $this->getTitle(),
         'language'  => $this->getLanguage(),
       ));
 
     if ($this->getArgument('json')) {
       echo json_encode($info)."\n";
     } else {
       echo $info['objectName'].': '.$info['uri']."\n";
     }
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistPatchWorkflow.php b/src/workflow/ArcanistPatchWorkflow.php
index 529045bd..9fdc4303 100644
--- a/src/workflow/ArcanistPatchWorkflow.php
+++ b/src/workflow/ArcanistPatchWorkflow.php
@@ -1,1093 +1,1079 @@
 <?php
 
 /**
  * Applies changes from Differential or a file to the working copy.
- *
- * @group workflow
  */
 final class ArcanistPatchWorkflow extends ArcanistBaseWorkflow {
 
   const SOURCE_BUNDLE         = 'bundle';
   const SOURCE_PATCH          = 'patch';
   const SOURCE_REVISION       = 'revision';
   const SOURCE_DIFF           = 'diff';
 
   private $source;
   private $sourceParam;
 
   public function getWorkflowName() {
     return 'patch';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **patch** __D12345__
       **patch** __--revision__ __revision_id__
       **patch** __--diff__ __diff_id__
       **patch** __--patch__ __file__
       **patch** __--arcbundle__ __bundlefile__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Apply the changes in a Differential revision, patchfile, or arc
           bundle to the working copy.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'revision' => array(
         'param' => 'revision_id',
         'paramtype' => 'complete',
         'help' =>
           "Apply changes from a Differential revision, using the most recent ".
           "diff that has been attached to it. You can run 'arc patch D12345' ".
           "as a shorthand.",
       ),
       'diff' => array(
         'param' => 'diff_id',
         'help' =>
           'Apply changes from a Differential diff. Normally you want to use '.
           '--revision to get the most recent changes, but you can '.
           'specifically apply an out-of-date diff or a diff which was never '.
           'attached to a revision by using this flag.',
       ),
       'arcbundle' => array(
         'param' => 'bundlefile',
         'paramtype' => 'file',
         'help' =>
           "Apply changes from an arc bundle generated with 'arc export'.",
       ),
       'patch' => array(
         'param' => 'patchfile',
         'paramtype' => 'file',
-        'help' =>
-          'Apply changes from a git patchfile or unified patchfile.',
+        'help' => 'Apply changes from a git patchfile or unified patchfile.',
       ),
       'encoding' => array(
         'param' => 'encoding',
-        'help' =>
-          'Attempt to convert non UTF-8 patch into specified encoding.',
+        'help' => 'Attempt to convert non UTF-8 patch into specified encoding.',
       ),
       'update' => array(
-        'supports' => array(
-          'git', 'svn', 'hg'
-        ),
-        'help' =>
-          'Update the local working copy before applying the patch.',
+        'supports' => array('git', 'svn', 'hg'),
+        'help' => 'Update the local working copy before applying the patch.',
         'conflicts' => array(
           'nobranch' => true,
           'bookmark' => true,
         ),
       ),
       'nocommit' => array(
-        'supports' => array(
-          'git', 'hg'
-        ),
+        'supports' => array('git', 'hg'),
         'help' =>
           'Normally under git/hg, if the patch is successful, the changes '.
           'are committed to the working copy. This flag prevents the commit.',
       ),
       'skip-dependencies' => array(
-        'supports' => array(
-          'git', 'hg'
-        ),
+        'supports' => array('git', 'hg'),
         'help' =>
           'Normally, if a patch has dependencies that are not present in the '.
           'working copy, arc tries to apply them as well. This flag prevents '.
           'such work.',
       ),
       'nobranch' => array(
-        'supports' => array(
-          'git', 'hg'
-        ),
+        'supports' => array('git', 'hg'),
         'help' =>
           'Normally, a new branch (git) or bookmark (hg) is created and then '.
           'the patch is applied and committed in the new branch/bookmark. '.
           'This flag cherry-picks the resultant commit onto the original '.
           'branch and deletes the temporary branch.',
         'conflicts' => array(
           'update' => true,
         ),
       ),
       'force' => array(
-        'help' =>
-          'Do not run any sanity checks.',
+        'help' => 'Do not run any sanity checks.',
       ),
       '*' => 'name',
     );
   }
 
   protected function didParseArguments() {
     $source = null;
     $requested = 0;
     if ($this->getArgument('revision')) {
       $source = self::SOURCE_REVISION;
       $requested++;
     }
     if ($this->getArgument('diff')) {
       $source = self::SOURCE_DIFF;
       $requested++;
     }
     if ($this->getArgument('arcbundle')) {
       $source = self::SOURCE_BUNDLE;
       $requested++;
     }
     if ($this->getArgument('patch')) {
       $source = self::SOURCE_PATCH;
       $requested++;
     }
 
     $use_revision_id = null;
     if ($this->getArgument('name')) {
       $namev = $this->getArgument('name');
       if (count($namev) > 1) {
         throw new ArcanistUsageException('Specify at most one revision name.');
       }
       $source = self::SOURCE_REVISION;
       $requested++;
 
       $use_revision_id = $this->normalizeRevisionID(head($namev));
     }
 
     if ($requested === 0) {
       throw new ArcanistUsageException(
         "Specify one of 'D12345', '--revision <revision_id>' (to select the ".
         "current changes attached to a Differential revision), ".
         "'--diff <diff_id>' (to select a specific, out-of-date diff or a ".
         "diff which is not attached to a revision), '--arcbundle <file>' ".
         "or '--patch <file>' to choose a patch source.");
     } else if ($requested > 1) {
       throw new ArcanistUsageException(
         "Options 'D12345', '--revision', '--diff', '--arcbundle' and ".
         "'--patch' are not compatible. Choose exactly one patch source.");
     }
 
     $this->source = $source;
     $this->sourceParam = nonempty(
       $use_revision_id,
       $this->getArgument($source));
   }
 
   public function requiresConduit() {
     return ($this->getSource() != self::SOURCE_PATCH);
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   private function getSource() {
     return $this->source;
   }
 
   private function getSourceParam() {
     return $this->sourceParam;
   }
 
   private function shouldCommit() {
     return !$this->getArgument('nocommit', false);
   }
 
   private function canBranch() {
     $repository_api = $this->getRepositoryAPI();
     return ($repository_api instanceof ArcanistGitAPI) ||
            ($repository_api instanceof ArcanistMercurialAPI);
   }
 
   private function shouldBranch() {
     $no_branch = $this->getArgument('nobranch', false);
     if ($no_branch) {
       return false;
     }
     return true;
   }
 
   private function getBranchName(ArcanistBundle $bundle) {
     $branch_name    = null;
     $repository_api = $this->getRepositoryAPI();
     $revision_id    = $bundle->getRevisionID();
     $base_name      = 'arcpatch';
     if ($revision_id) {
       $base_name .= "-D{$revision_id}";
     }
 
     $suffixes = array(null, '_1', '_2', '_3');
     foreach ($suffixes as $suffix) {
       $proposed_name = $base_name.$suffix;
 
       list($err) = $repository_api->execManualLocal(
         'rev-parse --verify %s',
         $proposed_name);
 
       // no error means git rev-parse found a branch
       if (!$err) {
         echo phutil_console_format(
           "Branch name {$proposed_name} already exists; trying a new name.\n");
         continue;
       } else {
         $branch_name = $proposed_name;
         break;
       }
     }
 
     if (!$branch_name) {
       throw new Exception(
-        'Arc was unable to automagically make a name for this patch.  '.
+        'Arc was unable to automagically make a name for this patch. '.
         'Please clean up your working copy and try again.'
       );
     }
 
     return $branch_name;
   }
 
   private function getBookmarkName(ArcanistBundle $bundle) {
-    $bookmark_name    = null;
+    $bookmark_name  = null;
     $repository_api = $this->getRepositoryAPI();
     $revision_id    = $bundle->getRevisionID();
     $base_name      = 'arcpatch';
     if ($revision_id) {
       $base_name .= "-D{$revision_id}";
     }
 
     $suffixes = array(null, '-1', '-2', '-3');
     foreach ($suffixes as $suffix) {
       $proposed_name = $base_name.$suffix;
 
       list($err) = $repository_api->execManualLocal(
         'log -r %s',
         hgsprintf('%s', $proposed_name));
 
       // no error means hg log found a bookmark
       if (!$err) {
         echo phutil_console_format(
           "Bookmark name %s already exists; trying a new name.\n",
           $proposed_name);
         continue;
       } else {
         $bookmark_name = $proposed_name;
         break;
       }
     }
 
     if (!$bookmark_name) {
       throw new Exception(
         'Arc was unable to automagically make a name for this patch. '.
         'Please clean up your working copy and try again.'
       );
     }
 
     return $bookmark_name;
   }
 
   private function createBranch(ArcanistBundle $bundle, $has_base_revision) {
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistGitAPI) {
       $branch_name = $this->getBranchName($bundle);
       $base_revision = $bundle->getBaseRevision();
 
       if ($base_revision && $has_base_revision) {
         $base_revision = $repository_api->getCanonicalRevisionName(
           $base_revision);
         $repository_api->execxLocal(
           'checkout -b %s %s',
           $branch_name,
           $base_revision);
       } else {
         $repository_api->execxLocal(
           'checkout -b %s',
           $branch_name);
       }
 
       echo phutil_console_format(
         "Created and checked out branch %s.\n",
         $branch_name);
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $branch_name = $this->getBookmarkName($bundle);
       $base_revision = $bundle->getBaseRevision();
 
       if ($base_revision && $has_base_revision) {
         $base_revision = $repository_api->getCanonicalRevisionName(
           $base_revision);
 
         echo "Updating to the revision's base commit\n";
         $repository_api->execPassthru(
           'update %s',
           $base_revision);
       }
 
-      $repository_api->execxLocal(
-        'bookmark %s',
-        $branch_name);
+      $repository_api->execxLocal('bookmark %s', $branch_name);
 
       echo phutil_console_format(
         "Created and checked out bookmark %s.\n",
         $branch_name);
     }
 
     return $branch_name;
   }
 
   private function shouldApplyDependencies() {
     return !$this->getArgument('skip-dependencies', false);
   }
 
   private function shouldUpdateWorkingCopy() {
     return $this->getArgument('update', false);
   }
 
   private function updateWorkingCopy() {
     echo "Updating working copy...\n";
     $this->getRepositoryAPI()->updateWorkingCopy();
     echo "Done.\n";
   }
 
   public function run() {
-
     $source = $this->getSource();
     $param = $this->getSourceParam();
     try {
       switch ($source) {
         case self::SOURCE_PATCH:
           if ($param == '-') {
             $patch = @file_get_contents('php://stdin');
             if (!strlen($patch)) {
               throw new ArcanistUsageException(
                 'Failed to read patch from stdin!');
             }
           } else {
             $patch = Filesystem::readFile($param);
           }
           $bundle = ArcanistBundle::newFromDiff($patch);
           break;
         case self::SOURCE_BUNDLE:
           $path = $this->getArgument('arcbundle');
           $bundle = ArcanistBundle::newFromArcBundle($path);
           break;
         case self::SOURCE_REVISION:
           $bundle = $this->loadRevisionBundleFromConduit(
             $this->getConduit(),
             $param);
           break;
         case self::SOURCE_DIFF:
           $bundle = $this->loadDiffBundleFromConduit(
             $this->getConduit(),
             $param);
           break;
       }
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-INVALID-SESSION') {
         // Phabricator is not configured to allow anonymous access to
         // Differential.
         $this->authenticateConduit();
         return $this->run();
       } else {
         throw $ex;
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
     if (!$try_encoding) {
       if ($this->requiresConduit()) {
         try {
           $try_encoding = $this->getRepositoryEncoding();
         } catch (ConduitClientException $e) {
           $try_encoding = null;
         }
       }
     }
 
     if ($try_encoding) {
       $bundle->setEncoding($try_encoding);
     }
 
     $sanity_check = !$this->getArgument('force', false);
 
     // we should update the working copy before we do ANYTHING else to
     // the working copy
     if ($this->shouldUpdateWorkingCopy()) {
       $this->updateWorkingCopy();
     }
 
     if ($sanity_check) {
       $this->requireCleanWorkingCopy();
     }
 
     $repository_api = $this->getRepositoryAPI();
     $has_base_revision = $repository_api->hasLocalCommit(
       $bundle->getBaseRevision());
     if ($this->canBranch() &&
          ($this->shouldBranch() ||
          ($this->shouldCommit() && $has_base_revision))) {
 
       if ($repository_api instanceof ArcanistGitAPI) {
         $original_branch = $repository_api->getBranchName();
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
         $original_branch = $repository_api->getActiveBookmark();
       }
 
       // If we weren't on a branch, then record the ref we'll return to
       // instead.
       if ($original_branch === null) {
         if ($repository_api instanceof ArcanistGitAPI) {
           $original_branch = $repository_api->getCanonicalRevisionName('HEAD');
         } else if ($repository_api instanceof ArcanistMercurialAPI) {
           $original_branch = $repository_api->getCanonicalRevisionName('.');
         }
       }
 
       $new_branch = $this->createBranch($bundle, $has_base_revision);
     }
     if (!$has_base_revision && $this->shouldApplyDependencies()) {
       $this->applyDependencies($bundle);
     }
 
     if ($sanity_check) {
       $this->sanityCheck($bundle);
     }
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $patch_err = 0;
 
       $copies = array();
       $deletes = array();
       $patches = array();
       $propset = array();
       $adds = array();
       $symlinks = array();
 
       $changes = $bundle->getChanges();
       foreach ($changes as $change) {
         $type = $change->getType();
         $should_patch = true;
 
         $filetype = $change->getFileType();
         switch ($filetype) {
           case ArcanistDiffChangeType::FILE_SYMLINK:
             $should_patch = false;
             $symlinks[] = $change;
             break;
         }
 
         switch ($type) {
           case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
           case ArcanistDiffChangeType::TYPE_MULTICOPY:
           case ArcanistDiffChangeType::TYPE_DELETE:
             $path = $change->getCurrentPath();
             $fpath = $repository_api->getPath($path);
             if (!@file_exists($fpath)) {
               $ok = phutil_console_confirm(
                 "Patch deletes file '{$path}', but the file does not exist in ".
                 "the working copy. Continue anyway?");
               if (!$ok) {
                 throw new ArcanistUserAbortException();
               }
             } else {
               $deletes[] = $change->getCurrentPath();
             }
             $should_patch = false;
             break;
           case ArcanistDiffChangeType::TYPE_COPY_HERE:
           case ArcanistDiffChangeType::TYPE_MOVE_HERE:
             $path = $change->getOldPath();
             $fpath = $repository_api->getPath($path);
             if (!@file_exists($fpath)) {
               $cpath = $change->getCurrentPath();
               if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
                 $verbs = 'copies';
               } else {
                 $verbs = 'moves';
               }
               $ok = phutil_console_confirm(
                 "Patch {$verbs} '{$path}' to '{$cpath}', but source path ".
                 "does not exist in the working copy. Continue anyway?");
               if (!$ok) {
                 throw new ArcanistUserAbortException();
               }
             } else {
               $copies[] = array(
                 $change->getOldPath(),
                 $change->getCurrentPath());
             }
             break;
           case ArcanistDiffChangeType::TYPE_ADD:
             $adds[] = $change->getCurrentPath();
             break;
         }
         if ($should_patch) {
           $cbundle = ArcanistBundle::newFromChanges(array($change));
           $patches[$change->getCurrentPath()] = $cbundle->toUnifiedDiff();
           $prop_old = $change->getOldProperties();
           $prop_new = $change->getNewProperties();
           $props = $prop_old + $prop_new;
           foreach ($props as $key => $ignored) {
             if (idx($prop_old, $key) !== idx($prop_new, $key)) {
               $propset[$change->getCurrentPath()][$key] = idx($prop_new, $key);
             }
           }
         }
       }
 
       // Before we start doing anything, create all the directories we're going
       // to add files to if they don't already exist.
       foreach ($copies as $copy) {
         list($src, $dst) = $copy;
         $this->createParentDirectoryOf($dst);
       }
 
       foreach ($patches as $path => $patch) {
         $this->createParentDirectoryOf($path);
       }
 
       foreach ($adds as $add) {
         $this->createParentDirectoryOf($add);
       }
 
       // TODO: The SVN patch workflow likely does not work on windows because
       // of the (cd ...) stuff.
 
       foreach ($copies as $copy) {
         list($src, $dst) = $copy;
         passthru(
           csprintf(
             '(cd %s; svn cp %s %s)',
             $repository_api->getPath(),
             ArcanistSubversionAPI::escapeFileNameForSVN($src),
             ArcanistSubversionAPI::escapeFileNameForSVN($dst)));
       }
 
       foreach ($deletes as $delete) {
         passthru(
           csprintf(
             '(cd %s; svn rm %s)',
             $repository_api->getPath(),
             ArcanistSubversionAPI::escapeFileNameForSVN($delete)));
       }
 
       foreach ($symlinks as $symlink) {
         $link_target = $symlink->getSymlinkTarget();
         $link_path = $symlink->getCurrentPath();
         switch ($symlink->getType()) {
           case ArcanistDiffChangeType::TYPE_ADD:
           case ArcanistDiffChangeType::TYPE_CHANGE:
           case ArcanistDiffChangeType::TYPE_MOVE_HERE:
           case ArcanistDiffChangeType::TYPE_COPY_HERE:
             execx(
               '(cd %s && ln -sf %s %s)',
               $repository_api->getPath(),
               $link_target,
               $link_path);
             break;
         }
       }
 
       foreach ($patches as $path => $patch) {
         $err = null;
         if ($patch) {
           $tmp = new TempFile();
           Filesystem::writeFile($tmp, $patch);
           passthru(
             csprintf(
               '(cd %s; patch -p0 < %s)',
               $repository_api->getPath(),
               $tmp),
             $err);
         } else {
           passthru(
             csprintf(
               '(cd %s; touch %s)',
               $repository_api->getPath(),
               $path),
             $err);
         }
         if ($err) {
           $patch_err = max($patch_err, $err);
         }
       }
 
       foreach ($adds as $add) {
         passthru(
           csprintf(
             '(cd %s; svn add %s)',
             $repository_api->getPath(),
             ArcanistSubversionAPI::escapeFileNameForSVN($add)));
       }
 
       foreach ($propset as $path => $changes) {
         foreach ($changes as $prop => $value) {
           if ($prop == 'unix:filemode') {
             // Setting this property also changes the file mode.
             $prop = 'svn:executable';
             $value = (octdec($value) & 0111 ? 'on' : null);
           }
           if ($value === null) {
             passthru(
               csprintf(
                 '(cd %s; svn propdel %s %s)',
                 $repository_api->getPath(),
                 $prop,
                 ArcanistSubversionAPI::escapeFileNameForSVN($path)));
           } else {
             passthru(
               csprintf(
                 '(cd %s; svn propset %s %s %s)',
                 $repository_api->getPath(),
                 $prop,
                 $value,
                 ArcanistSubversionAPI::escapeFileNameForSVN($path)));
           }
         }
       }
 
       if ($patch_err == 0) {
         echo phutil_console_format(
           "<bg:green>** OKAY **</bg> Successfully applied patch ".
           "to the working copy.\n");
       } else {
         echo phutil_console_format(
           "\n\n<bg:yellow>** WARNING **</bg> Some hunks could not be applied ".
           "cleanly by the unix 'patch' utility. Your working copy may be ".
           "different from the revision's base, or you may be in the wrong ".
           "subdirectory. You can export the raw patch file using ".
           "'arc export --unified', and then try to apply it by fiddling with ".
           "options to 'patch' (particularly, -p), or manually. The output ".
           "above, from 'patch', may be helpful in figuring out what went ".
           "wrong.\n");
       }
 
       return $patch_err;
     } else if ($repository_api instanceof ArcanistGitAPI) {
 
       $patchfile = new TempFile();
       Filesystem::writeFile($patchfile, $bundle->toGitPatch());
 
       $passthru = new PhutilExecPassthru(
         'git apply --index --reject -- %s',
         $patchfile);
       $passthru->setCWD($repository_api->getPath());
       $err = $passthru->execute();
 
       if ($err) {
         echo phutil_console_format(
           "\n<bg:red>** Patch Failed! **</bg>\n");
 
         // NOTE: Git patches may fail if they change the case of a filename
         // (for instance, from 'example.c' to 'Example.c'). As of now, Git
         // can not apply these patches on case-insensitive filesystems and
         // there is no way to build a patch which works.
 
         throw new ArcanistUsageException('Unable to apply patch!');
       }
 
       // in case there were any submodule changes involved
       $repository_api->execpassthru(
         'submodule update --init --recursive');
 
       if ($this->shouldCommit()) {
         if ($bundle->getFullAuthor()) {
           $author_cmd = csprintf('--author=%s', $bundle->getFullAuthor());
         } else {
           $author_cmd = '';
         }
 
         $commit_message = $this->getCommitMessage($bundle);
         $future = $repository_api->execFutureLocal(
           'commit -a %C -F - --no-verify',
           $author_cmd);
         $future->write($commit_message);
         $future->resolvex();
         $verb = 'committed';
       } else {
         $verb = 'applied';
       }
 
       if ($this->canBranch() &&
           !$this->shouldBranch() &&
           $this->shouldCommit() && $has_base_revision) {
         $repository_api->execxLocal('checkout %s', $original_branch);
         $ex = null;
         try {
           $repository_api->execxLocal('cherry-pick %s', $new_branch);
         } catch (Exception $ex) {
           // do nothing
         }
         $repository_api->execxLocal('branch -D %s', $new_branch);
         if ($ex) {
           echo phutil_console_format(
             "\n<bg:red>** Cherry Pick Failed!**</bg>\n");
           throw $ex;
         }
       }
 
       echo phutil_console_format(
         "<bg:green>** OKAY **</bg> Successfully {$verb} patch.\n");
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
 
       $future = $repository_api->execFutureLocal(
         'import --no-commit -');
       $future->write($bundle->toGitPatch());
 
       try {
         $future->resolvex();
       } catch (CommandException $ex) {
         echo phutil_console_format(
           "\n<bg:red>** Patch Failed! **</bg>\n");
         $stderr = $ex->getStdErr();
         if (preg_match('/case-folding collision/', $stderr)) {
           echo phutil_console_wrap(
             phutil_console_format(
               "\n<bg:yellow>** WARNING **</bg> This patch may have failed ".
               "because it attempts to change the case of a filename (for ".
               "instance, from 'example.c' to 'Example.c'). Mercurial cannot ".
               "apply patches like this on case-insensitive filesystems. You ".
               "must apply this patch manually.\n"));
         }
         throw $ex;
       }
 
       if ($this->shouldCommit()) {
         $author = coalesce($bundle->getFullAuthor(), $bundle->getAuthorName());
         if ($author !== null) {
           $author_cmd = csprintf('-u %s', $author);
         } else {
           $author_cmd = '';
         }
 
         $commit_message = $this->getCommitMessage($bundle);
         $future = $repository_api->execFutureLocal(
           'commit %C -l -',
           $author_cmd);
         $future->write($commit_message);
         $future->resolvex();
 
         if (!$this->shouldBranch() && $has_base_revision) {
           $original_rev = $repository_api->getCanonicalRevisionName(
             $original_branch);
           $current_parent = $repository_api->getCanonicalRevisionName(
             hgsprintf('%s^', $new_branch));
 
           $err = 0;
           if ($original_rev != $current_parent) {
             list($err) = $repository_api->execManualLocal(
               'rebase --dest %s --rev %s',
               hgsprintf('%s', $original_branch),
               hgsprintf('%s', $new_branch));
           }
 
           $repository_api->execxLocal('bookmark --delete %s', $new_branch);
           if ($err) {
             $repository_api->execManualLocal('rebase --abort');
             throw new ArcanistUsageException(phutil_console_format(
               "\n<bg:red>** Rebase onto $original_branch failed!**</bg>\n"));
           }
         }
 
         $verb = 'committed';
       } else {
         $verb = 'applied';
       }
 
       echo phutil_console_format(
         "<bg:green>** OKAY **</bg> Successfully {$verb} patch.\n");
 
     } else {
       throw new Exception('Unknown version control system.');
     }
 
     return 0;
   }
 
   private function getCommitMessage(ArcanistBundle $bundle) {
     $revision_id    = $bundle->getRevisionID();
     $commit_message = null;
     $prompt_message = null;
 
     // if we have a revision id the commit message is in differential
 
     // TODO: See T848 for the authenticated stuff.
     if ($revision_id && $this->isConduitAuthenticated()) {
 
       $conduit        = $this->getConduit();
       $commit_message = $conduit->callMethodSynchronous(
         'differential.getcommitmessage',
         array(
           'revision_id' => $revision_id,
         ));
       $prompt_message = "  Note arcanist failed to load the commit message ".
                         "from differential for revision D{$revision_id}.";
     }
 
     // no revision id or failed to fetch commit message so get it from the
     // user on the command line
     if (!$commit_message) {
       $template =
         "\n\n".
-        "# Enter a commit message for this patch.  If you just want to apply ".
+        "# Enter a commit message for this patch. If you just want to apply ".
         "the patch to the working copy without committing, re-run arc patch ".
         "with the --nocommit flag.".
         $prompt_message.
         "\n";
 
       $commit_message = $this->newInteractiveEditor($template)
         ->setName('arcanist-patch-commit-message')
         ->editInteractively();
 
       $commit_message = ArcanistCommentRemover::removeComments($commit_message);
       if (!strlen(trim($commit_message))) {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $commit_message;
   }
 
   public function getShellCompletions(array $argv) {
     // TODO: Pull open diffs from 'arc list'?
     return array('ARGUMENT');
   }
 
   private function applyDependencies(ArcanistBundle $bundle) {
     // check for (and automagically apply on the user's be-hest) any revisions
     // this patch depends on
     $graph = $this->buildDependencyGraph($bundle);
     if ($graph) {
       $start_phid = $graph->getStartPHID();
       $cycle_phids = $graph->detectCycles($start_phid);
       if ($cycle_phids) {
         $phids = array_keys($graph->getNodes());
         $issue = 'The dependencies for this patch have a cycle. Applying them '.
                  'is not guaranteed to work. Continue anyway?';
         $okay = phutil_console_confirm($issue, true);
       } else {
         $phids = $graph->getTopographicallySortedNodes();
         $phids = array_reverse($phids);
         $okay = true;
       }
 
       if (!$okay) {
         return;
       }
 
       $dep_on_revs = $this->getConduit()->callMethodSynchronous(
         'differential.query',
         array(
           'phids' => $phids,
           'arcanistProjects' => array($bundle->getProjectID())
         ));
       $revs = array();
       foreach ($dep_on_revs as $dep_on_rev) {
         $revs[$dep_on_rev['phid']] = 'D'.$dep_on_rev['id'];
       }
       // order them in case we got a topological sort earlier
       $revs = array_select_keys($revs, $phids);
       if (!empty($revs)) {
         $base_args = array(
           '--force',
           '--skip-dependencies',
           '--nobranch');
         if (!$this->shouldCommit()) {
           $base_args[] = '--nocommit';
         }
 
         foreach ($revs as $phid => $diff_id) {
           // we'll apply this, the actual patch, later
           // this should be the last in the list
           if ($phid == $start_phid) {
             continue;
           }
           $args = $base_args;
           $args[] = $diff_id;
           $apply_workflow = $this->buildChildWorkflow(
             'patch',
             $args);
           $apply_workflow->run();
         }
       }
     }
   }
 
   /**
    * Do the best we can to prevent PEBKAC and id10t issues.
    */
   private function sanityCheck(ArcanistBundle $bundle) {
     $repository_api = $this->getRepositoryAPI();
 
     // Check to see if the bundle's project id matches the working copy
     // project id
     $bundle_project_id = $bundle->getProjectID();
     $working_copy_project_id = $this->getWorkingCopy()->getProjectID();
     if (empty($bundle_project_id)) {
       // this means $source is SOURCE_PATCH || SOURCE_BUNDLE w/ $version = 0
       // they don't come with a project id so just do nothing
     } else if ($bundle_project_id != $working_copy_project_id) {
       if ($working_copy_project_id) {
         $issue =
-          "This patch is for the '{$bundle_project_id}' project,  but the ".
+          "This patch is for the '{$bundle_project_id}' project, but the ".
           "working copy belongs to the '{$working_copy_project_id}' project.";
       } else {
         $issue =
           "This patch is for the '{$bundle_project_id}' project, but the ".
           "working copy does not have an '.arcconfig' file to identify which ".
           "project it belongs to.";
       }
       $ok = phutil_console_confirm(
         "{$issue} Still try to apply the patch?",
         $default_no = false);
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     // Check to see if the bundle's base revision matches the working copy
     // base revision
     if ($repository_api->supportsLocalCommits()) {
       $bundle_base_rev = $bundle->getBaseRevision();
       if (empty($bundle_base_rev)) {
         // this means $source is SOURCE_PATCH || SOURCE_BUNDLE w/ $version < 2
         // they don't have a base rev so just do nothing
         $commit_exists = true;
       } else {
         $commit_exists =
           $repository_api->hasLocalCommit($bundle_base_rev);
       }
       if (!$commit_exists) {
         // we have a problem...! lots of work because we need to ask
         // differential for revision information for these base revisions
         // to improve our error message.
         $bundle_base_rev_str = null;
         $source_base_rev     = $repository_api->getWorkingCopyRevision();
         $source_base_rev_str = null;
 
         if ($repository_api instanceof ArcanistGitAPI) {
           $hash_type = ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT;
         } else if ($repository_api instanceof ArcanistMercurialAPI) {
           $hash_type = ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT;
         } else {
           $hash_type = null;
         }
 
         if ($hash_type) {
           // 2 round trips because even though we could send off one query
           // we wouldn't be able to tell which revisions were for which hash
           $hash = array($hash_type, $bundle_base_rev);
           $bundle_revision = $this->loadRevisionFromHash($hash);
           $hash = array($hash_type, $source_base_rev);
           $source_revision = $this->loadRevisionFromHash($hash);
 
           if ($bundle_revision) {
             $bundle_base_rev_str = $bundle_base_rev.
-                                   ' \ D'.$bundle_revision['id'];
+              ' \ D'.$bundle_revision['id'];
           }
           if ($source_revision) {
             $source_base_rev_str = $source_base_rev.
-                                   ' \ D'.$source_revision['id'];
+              ' \ D'.$source_revision['id'];
           }
         }
-        $bundle_base_rev_str = nonempty($bundle_base_rev_str,
-                                        $bundle_base_rev);
-        $source_base_rev_str = nonempty($source_base_rev_str,
-                                        $source_base_rev);
+        $bundle_base_rev_str = nonempty(
+          $bundle_base_rev_str,
+          $bundle_base_rev);
+        $source_base_rev_str = nonempty(
+          $source_base_rev_str,
+          $source_base_rev);
 
         $ok = phutil_console_confirm(
           "This diff is against commit {$bundle_base_rev_str}, but the ".
           "commit is nowhere in the working copy. Try to apply it against ".
           "the current working copy state? ({$source_base_rev_str})",
           $default_no = false);
         if (!$ok) {
           throw new ArcanistUserAbortException();
         }
       }
     }
   }
 
   /**
    * Create parent directories one at a time, since we need to "svn add" each
    * one. (Technically we could "svn add" just the topmost new directory.)
    */
   private function createParentDirectoryOf($path) {
     $repository_api = $this->getRepositoryAPI();
     $dir = dirname($path);
     if (Filesystem::pathExists($dir)) {
       return;
     } else {
       // Make sure the parent directory exists before we make this one.
       $this->createParentDirectoryOf($dir);
       execx(
         '(cd %s && mkdir %s)',
         $repository_api->getPath(),
         $dir);
       passthru(
         csprintf(
           '(cd %s && svn add %s)',
           $repository_api->getPath(),
           $dir));
     }
   }
 
   private function loadRevisionFromHash($hash) {
     // TODO -- de-hack this as permissions become more clear with things
     // like T848 (add scope to OAuth)
     if (!$this->isConduitAuthenticated()) {
       return null;
     }
 
     $conduit = $this->getConduit();
 
     $revisions = $conduit->callMethodSynchronous(
       'differential.query',
       array(
         'commitHashes' => array($hash),
       ));
 
 
     // grab the latest closed revision only
     $found_revision = null;
     $revisions = isort($revisions, 'dateModified');
     foreach ($revisions as $revision) {
       if ($revision['status'] == ArcanistDifferentialRevisionStatus::CLOSED) {
         $found_revision = $revision;
       }
     }
     return $found_revision;
   }
 
   private function buildDependencyGraph(ArcanistBundle $bundle) {
     $graph = null;
     if ($this->getRepositoryAPI() instanceof ArcanistSubversionAPI) {
       return $graph;
     }
     $revision_id = $bundle->getRevisionID();
     if ($revision_id) {
       $revisions = $this->getConduit()->callMethodSynchronous(
         'differential.query',
         array(
           'ids' => array($revision_id),
         ));
       if ($revisions) {
         $revision = head($revisions);
         $rev_auxiliary = idx($revision, 'auxiliary', array());
         $phids = idx($rev_auxiliary, 'phabricator:depends-on', array());
         if ($phids) {
           $revision_phid = $revision['phid'];
           $graph = id(new ArcanistDifferentialDependencyGraph())
             ->setConduit($this->getConduit())
             ->setRepositoryAPI($this->getRepositoryAPI())
             ->setStartPHID($revision_phid)
             ->addNodes(array($revision_phid => $phids))
             ->loadGraph();
         }
       }
     }
 
     return $graph;
   }
+
 }
diff --git a/src/workflow/ArcanistRevertWorkflow.php b/src/workflow/ArcanistRevertWorkflow.php
index 4b1b9491..01692557 100644
--- a/src/workflow/ArcanistRevertWorkflow.php
+++ b/src/workflow/ArcanistRevertWorkflow.php
@@ -1,37 +1,37 @@
 <?php
+
 /**
- * Redirects to arc backout workflow
- * @group workflow
+ * Redirects to `arc backout` workflow.
  */
-
 final class ArcanistRevertWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'revert';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **revert**
 EOTEXT
     );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
     Please use arc backout instead
 EOTEXT
     );
   }
 
   public function getArguments() {
     return array(
       '*' => 'input',
     );
   }
 
   public function run() {
     $console = PhutilConsole::getConsole();
     $console->writeOut("Please use arc backout instead.\n");
   }
+
 }
diff --git a/src/workflow/ArcanistSetConfigWorkflow.php b/src/workflow/ArcanistSetConfigWorkflow.php
index 5013a529..3c9b98bd 100644
--- a/src/workflow/ArcanistSetConfigWorkflow.php
+++ b/src/workflow/ArcanistSetConfigWorkflow.php
@@ -1,115 +1,115 @@
 <?php
 
 /**
  * Write configuration settings.
  */
 final class ArcanistSetConfigWorkflow extends ArcanistBaseWorkflow {
 
   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__
+          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
+          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' => '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();
 
     $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 "Deleted key '{$key}' from {$which} config.\n";
       } else {
         echo "Deleted key '{$key}' from {$which} config (was {$old}).\n";
       }
     } 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 "Set key '{$key}' = {$val} in {$which} config.\n";
       } else {
         echo "Set key '{$key}' = {$val} in {$which} config (was {$old}).\n";
       }
     }
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistShellCompleteWorkflow.php b/src/workflow/ArcanistShellCompleteWorkflow.php
index e4086bc5..c8469558 100644
--- a/src/workflow/ArcanistShellCompleteWorkflow.php
+++ b/src/workflow/ArcanistShellCompleteWorkflow.php
@@ -1,197 +1,196 @@
 <?php
 
 /**
  * Powers shell-completion scripts.
- *
- * @group workflow
  */
 final class ArcanistShellCompleteWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'shell-complete';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **shell-complete** __--current__ __N__ -- [__argv__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: bash, etc.
           Implements shell completion. To use shell completion, source the
           appropriate script from 'resources/shell/' in your .shellrc.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'current' => array(
         'param' => 'cursor_position',
         'paramtype' => 'int',
         'help' => 'Current term in the argument list being completed.',
       ),
       '*' => 'argv',
     );
   }
 
   public function shouldShellComplete() {
     return false;
   }
 
   public function run() {
     $pos  = $this->getArgument('current');
     $argv = $this->getArgument('argv', array());
     $argc = count($argv);
     if ($pos === null) {
       $pos = $argc - 1;
     }
 
     if ($pos > $argc) {
       throw new ArcanistUsageException(
         'Specified position is greater than the number of arguments provided.');
     }
 
     // Determine which revision control system the working copy uses, so we
     // can filter out commands and flags which aren't supported. If we can't
     // figure it out, just return all flags/commands.
     $vcs = null;
 
     // We have to build our own because if we requiresWorkingCopy() we'll throw
     // if we aren't in a .arcconfig directory. We probably still can't do much,
     // but commands can raise more detailed errors.
     $configuration_manager = $this->getConfigurationManager();
     $working_copy = ArcanistWorkingCopyIdentity::newFromPath(getcwd());
     if ($working_copy->getVCSType()) {
       $configuration_manager->setWorkingCopyIdentity($working_copy);
       $repository_api = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
         $configuration_manager);
 
       $vcs = $repository_api->getSourceControlSystemName();
     }
 
     $arc_config = $this->getArcanistConfiguration();
 
     if ($pos <= 1) {
       $workflows = $arc_config->buildAllWorkflows();
 
       $complete = array();
       foreach ($workflows as $name => $workflow) {
         if (!$workflow->shouldShellComplete()) {
           continue;
         }
 
         $supported = $workflow->getSupportedRevisionControlSystems();
 
         $ok = (in_array('any', $supported) || in_array($vcs, $supported));
         if (!$ok) {
           continue;
         }
 
         $complete[] = $name;
       }
 
       // Also permit autocompletion of "arc alias" commands.
       $aliases =  ArcanistAliasWorkflow::getAliases($configuration_manager);
       foreach ($aliases as $key => $value) {
         $complete[] = $key;
       }
 
       echo implode(' ', $complete)."\n";
       return 0;
     } else {
       $workflow = $arc_config->buildWorkflow($argv[1]);
       if (!$workflow) {
         list($new_command, $new_args) = ArcanistAliasWorkflow::resolveAliases(
           $argv[1],
           $arc_config,
           array_slice($argv, 2),
           $configuration_manager);
         if ($new_command) {
           $workflow = $arc_config->buildWorkflow($new_command);
         }
         if (!$workflow) {
           return 1;
         } else {
           $argv = array_merge(
             array($argv[0]),
             array($new_command),
             $new_args);
         }
       }
 
       $arguments = $workflow->getArguments();
 
       $prev = idx($argv, $pos - 1, null);
       if (!strncmp($prev, '--', 2)) {
         $prev = substr($prev, 2);
       } else {
         $prev = null;
       }
 
       if ($prev !== null &&
           isset($arguments[$prev]) &&
           isset($arguments[$prev]['param'])) {
 
         $type = idx($arguments[$prev], 'paramtype');
         switch ($type) {
           case 'file':
             echo "FILE\n";
             break;
           case 'complete':
             echo implode(' ', $workflow->getShellCompletions($argv))."\n";
             break;
           default:
             echo "ARGUMENT\n";
             break;
         }
         return 0;
       } else {
         $output = array();
         foreach ($arguments as $argument => $spec) {
           if ($argument == '*') {
             continue;
           }
           if ($vcs &&
               isset($spec['supports']) &&
               !in_array($vcs, $spec['supports'])) {
             continue;
           }
           $output[] = '--'.$argument;
         }
 
         $cur = idx($argv, $pos, '');
         $any_match = false;
 
         if (strlen($cur)) {
           foreach ($output as $possible) {
             if (!strncmp($possible, $cur, strlen($cur))) {
               $any_match = true;
             }
           }
         }
 
         if (!$any_match && isset($arguments['*'])) {
           // TODO: This is mega hacktown but something else probably breaks
           // if we use a rich argument specification; fix it when we move to
           // PhutilArgumentParser since everything will need to be tested then
           // anyway.
           if ($arguments['*'] == 'branch' && isset($repository_api)) {
             $branches = $repository_api->getAllBranches();
             $branches = ipull($branches, 'name');
             $output = $branches;
           } else {
             $output = array('FILE');
           }
         }
 
         echo implode(' ', $output)."\n";
 
         return 0;
       }
     }
   }
+
 }
diff --git a/src/workflow/ArcanistSvnHookPreCommitWorkflow.php b/src/workflow/ArcanistSvnHookPreCommitWorkflow.php
index 05a41791..baae1958 100644
--- a/src/workflow/ArcanistSvnHookPreCommitWorkflow.php
+++ b/src/workflow/ArcanistSvnHookPreCommitWorkflow.php
@@ -1,232 +1,230 @@
 <?php
 
 /**
  * Installable as an SVN "pre-commit" hook.
- *
- * @group workflow
  */
 final class ArcanistSvnHookPreCommitWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'svn-hook-pre-commit';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **svn-hook-pre-commit** __repository__ __transaction__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn
           You can install this as an SVN pre-commit hook. For more information,
           see the article "Installing Arcanist SVN Hooks" in the Arcanist
           documentation.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'svnargs',
     );
   }
 
   public function shouldShellComplete() {
     return false;
   }
 
   public function run() {
-
     $svnargs = $this->getArgument('svnargs');
     $repository = $svnargs[0];
     $transaction = $svnargs[1];
 
     list($commit_message) = execx(
       'svnlook log --transaction %s %s',
       $transaction,
       $repository);
 
     if (strpos($commit_message, '@bypass-lint') !== false) {
       return 0;
     }
 
 
     // TODO: Do stuff with commit message.
 
     list($changed) = execx(
       'svnlook changed --transaction %s %s',
       $transaction,
       $repository);
 
     $paths = array();
     $changed = explode("\n", trim($changed));
     foreach ($changed as $line) {
       $matches = null;
       preg_match('/^..\s*(.*)$/', $line, $matches);
       $paths[$matches[1]] = strlen($matches[1]);
     }
 
     $resolved = array();
     $failed = array();
     $missing = array();
     $found = array();
     asort($paths);
 
     foreach ($paths as $path => $length) {
       foreach ($resolved as $rpath => $root) {
         if (!strncmp($path, $rpath, strlen($rpath))) {
           $resolved[$path] = $root;
           continue 2;
         }
       }
       $config = $path;
 
       if (basename($config) == '.arcconfig') {
         $resolved[$config] = $config;
         continue;
       }
 
       $config = rtrim($config, '/');
       $last_config = $config;
       do {
         if (!empty($missing[$config])) {
           break;
         } else if (!empty($found[$config])) {
           $resolved[$path] = $found[$config];
           break;
         }
         list($err) = exec_manual(
           'svnlook cat --transaction %s %s %s',
           $transaction,
           $repository,
           $config ? $config.'/.arcconfig' : '.arcconfig');
         if ($err) {
           $missing[$path] = true;
         } else {
           $resolved[$path] = $config ? $config.'/.arcconfig' : '.arcconfig';
           $found[$config] = $resolved[$path];
           break;
         }
         $config = dirname($config);
         if ($config == '.') {
           $config = '';
         }
         if ($config == $last_config) {
           break;
         }
         $last_config = $config;
       } while (true);
 
       if (empty($resolved[$path])) {
         $failed[] = $path;
       }
     }
 
     if ($failed && $resolved) {
       $failed_paths = '        '.implode("\n        ", $failed);
       $resolved_paths = '        '.implode("\n        ", array_keys($resolved));
       throw new ArcanistUsageException(
         "This commit includes a mixture of files in Arcanist projects and ".
         "outside of Arcanist projects. A commit which affects an Arcanist ".
         "project must affect only that project.\n\n".
         "Files in projects:\n\n".
         $resolved_paths."\n\n".
         "Files not in projects:\n\n".
         $failed_paths);
     }
 
     if (!$resolved) {
       // None of the affected paths are beneath a .arcconfig file.
       return 0;
     }
 
     $groups = array();
     foreach ($resolved as $path => $project) {
       $groups[$project][] = $path;
     }
     if (count($groups) > 1) {
       $message = array();
       foreach ($groups as $project => $group) {
         $message[] = "Files underneath '{$project}':\n\n";
         $message[] = "        ".implode("\n        ", $group)."\n\n";
       }
       $message = implode('', $message);
       throw new ArcanistUsageException(
         "This commit includes a mixture of files from different Arcanist ".
         "projects. A commit which affects an Arcanist project must affect ".
         "only that project.\n\n".
         $message);
     }
 
     $config_file = key($groups);
     $project_root = dirname($config_file);
     $paths = reset($groups);
 
     list($config) = execx(
       'svnlook cat --transaction %s %s %s',
       $transaction,
       $repository,
       $config_file);
 
     $working_copy = ArcanistWorkingCopyIdentity::newFromRootAndConfigFile(
       $project_root,
       $config,
       $config_file." (svnlook: {$transaction} {$repository})");
 
     $repository_api = new ArcanistSubversionHookAPI(
       $project_root,
       $transaction,
       $repository);
 
     $lint_engine = $working_copy->getProjectConfig('lint.engine');
     if (!$lint_engine) {
       return 0;
     }
 
     $engine = newv($lint_engine, array());
     $engine->setWorkingCopy($working_copy);
     $engine->setConfigurationManager($this->getConfigurationManager());
     $engine->setMinimumSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
     $engine->setPaths($paths);
     $engine->setCommitHookMode(true);
     $engine->setHookAPI($repository_api);
 
     try {
       $results = $engine->run();
     } catch (ArcanistNoEffectException $no_effect) {
       // Nothing to do, bail out.
       return 0;
     }
 
     $failures = array();
     foreach ($results as $result) {
       if (!$result->getMessages()) {
         continue;
       }
       $failures[] = $result;
     }
 
     if ($failures) {
       $at = '@';
       $msg = phutil_console_format(
         "\n**LINT ERRORS**\n\n".
         "This changeset has lint errors. You must fix all lint errors before ".
         "you can commit.\n\n".
         "You can add '{$at}bypass-lint' to your commit message to disable ".
         "lint checks for this commit, or '{$at}nolint' to the file with ".
         "errors to disable lint for that file.\n\n");
       echo phutil_console_wrap($msg);
 
       $renderer = new ArcanistLintConsoleRenderer();
       foreach ($failures as $result) {
         echo $renderer->renderLintResult($result);
       }
       return 1;
     }
 
     return 0;
   }
+
 }
diff --git a/src/workflow/ArcanistTasksWorkflow.php b/src/workflow/ArcanistTasksWorkflow.php
index f88634fd..7553fe94 100644
--- a/src/workflow/ArcanistTasksWorkflow.php
+++ b/src/workflow/ArcanistTasksWorkflow.php
@@ -1,212 +1,210 @@
 <?php
 
 /**
- * Displays User Tasks
- *
- * @group workflow
+ * Displays User Tasks.
  */
 final class ArcanistTasksWorkflow extends ArcanistBaseWorkflow {
 
   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' => 'Show tasks that or open or closed, default is open.',
       ),
       'owner' => array(
         'param' => 'username',
         'paramtype' => 'username',
         'help' =>
           'Only show tasks assigned to the given username, '.
-            'also accepts @all to show all, default is you.',
+          'also accepts @all to show all, default is you.',
         'conflict' => array(
           'unassigned' => '--owner suppresses unassigned',
         ),
       ),
       'order' => array(
         'param' => 'task_order',
         'help' =>
           'Arrange tasks based on priority, created, or modified, '.
-            'default is priority.',
+          'default is priority.',
       ),
       'limit' => array(
         'param' => 'n',
         'paramtype' => 'int',
         'help' => 'Limit the amount of tasks outputted, default is all.',
       ),
       'unassigned' => array(
         'help' => '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);
     } 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 "No tasks found.\n";
       return 0;
     }
 
     $table = id(new PhutilConsoleTable())
       ->setShowHeader(false)
       ->addColumn('id', array('title' => 'ID'))
       ->addColumn('title', array('title' => 'Title'))
       ->addColumn('priority', array('title' => 'Priority'))
       ->addColumn('status', array('title' => 'Status'));
 
     foreach ($this->tasks as $task) {
       $output = array();
 
       // Render the "T123" column.
       $task_id = 'T'.$task['id'];
       $formatted_task_id = phutil_console_format('**%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 = phutil_console_format(
         "<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 = phutil_console_format(
           "<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/ArcanistTodoWorkflow.php b/src/workflow/ArcanistTodoWorkflow.php
index 8a1a248e..b9f99022 100644
--- a/src/workflow/ArcanistTodoWorkflow.php
+++ b/src/workflow/ArcanistTodoWorkflow.php
@@ -1,92 +1,90 @@
 <?php
 
 /**
- * Quickly create a task
- *
- * @group workflow
+ * Quickly create a task.
  */
 final class ArcanistTodoWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'todo';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **todo** __summary__ [__options__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
         Quickly create a task for yourself.
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function desiresWorkingCopy() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
 
   public function getArguments() {
     return array(
       '*' => 'summary',
       'cc' => array(
         'param' => 'cc',
         'short' => 'C',
         'repeat' => true,
         'help'  => 'Other users to CC on the new task.',
       ),
     );
   }
 
   public function run() {
     $summary = implode(' ', $this->getArgument('summary'));
     $ccs = $this->getArgument('cc');
     $conduit = $this->getConduit();
 
     if (trim($summary) == '') {
       echo "Please provide a summary.\n";
       return;
     }
 
     $args = array(
       'title' => $summary,
       'ownerPHID' => $this->getUserPHID()
     );
 
     if ($ccs) {
       $phids = array();
       $users = $conduit->callMethodSynchronous(
         'user.query',
         array(
           'usernames' => $ccs
         ));
       foreach ($users as $user => $info) {
         $phids[] = $info['phid'];
       }
       $args['ccPHIDs'] = $phids;
     }
 
     $result = $conduit->callMethodSynchronous(
       'maniphest.createtask',
       $args);
 
     echo phutil_console_format(
       "Created task T%s: '<fg:green>**%s**</fg>' at <fg:blue>**%s**</fg>\n",
       $result['id'],
       $result['title'],
       $result['uri']);
   }
 
 }
diff --git a/src/workflow/ArcanistUnitWorkflow.php b/src/workflow/ArcanistUnitWorkflow.php
index cdfa2de1..61362231 100644
--- a/src/workflow/ArcanistUnitWorkflow.php
+++ b/src/workflow/ArcanistUnitWorkflow.php
@@ -1,357 +1,356 @@
 <?php
 
 /**
  * Runs unit tests which cover your changes.
- *
- * @group workflow
  */
 final class ArcanistUnitWorkflow extends ArcanistBaseWorkflow {
 
   const RESULT_OKAY      = 0;
   const RESULT_UNSOUND   = 1;
   const RESULT_FAIL      = 2;
   const RESULT_SKIP      = 3;
   const RESULT_POSTPONED = 4;
 
   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' => 'Run unit tests covering changes since a specific revision.',
         'supports' => array(
           'git',
           'hg',
         ),
         'nosupport' => array(
           'svn' => 'Arc unit does not currently support --rev in SVN.',
         ),
       ),
       'engine' => array(
         'param' => 'classname',
         'help' =>
           'Override configured unit engine for this project.'
       ),
       'coverage' => array(
         'help' => 'Always enable coverage information.',
         'conflicts' => array(
           'no-coverage' => null,
         ),
       ),
       'no-coverage' => array(
         'help' => 'Always disable coverage information.',
       ),
       'detailed-coverage' => array(
         'help' => 'Show a detailed coverage report on the CLI. Implies '.
                   '--coverage.',
       ),
       'json' => array(
         'help' => 'Report results in JSON format.',
       ),
       'output' => array(
         'param' => 'format',
         'help' =>
           "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' => 'Only one output format allowed',
           'ugly' => 'Only one output format allowed',
         )
       ),
       'everything' => array(
         'help' => 'Run every test.',
         'conflicts' => array(
           'rev' => '--everything runs all tests.',
         ),
       ),
       'ugly' => array(
         'help' => 'With --json, use uglier (but more efficient) formatting.',
       ),
       '*' => 'paths',
     );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function getEngine() {
     return $this->engine;
   }
 
   public function run() {
 
     $working_copy = $this->getWorkingCopy();
 
     $engine_class = $this->getArgument(
       'engine',
       $this->getConfigurationManager()->getConfigFromAnySource('unit.engine'));
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         'No unit test engine is configured for this project. Edit .arcconfig '.
         'to specify a unit test engine.');
     }
 
     $paths = $this->getArgument('paths');
     $rev = $this->getArgument('rev');
     $everything = $this->getArgument('everything');
     if ($everything && $paths) {
       throw new ArcanistUsageException(
         'You can not specify paths with --everything. The --everything '.
         'flag runs every test.');
     }
 
     $paths = $this->selectPathsForWorkflow($paths, $rev);
 
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, 'ArcanistBaseUnitTestEngine')) {
       throw new ArcanistUsageException(
         "Configured unit test engine '{$engine_class}' is not a subclass of ".
         "'ArcanistBaseUnitTestEngine'.");
     }
 
     $this->engine = newv($engine_class, array());
     $this->engine->setWorkingCopy($working_copy);
     $this->engine->setConfigurationManager($this->getConfigurationManager());
     if ($everything) {
       $this->engine->setRunAllTests(true);
     } else {
       $this->engine->setPaths($paths);
     }
     $this->engine->setArguments($this->getPassthruArgumentsAsMap('unit'));
 
     $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);
 
     // Enable possible async tests only for 'arc diff' not 'arc unit'
     if ($this->getParentWorkflow()) {
       $this->engine->setEnableAsyncTests(true);
     } else {
       $this->engine->setEnableAsyncTests(false);
     }
 
     $results = $this->engine->run();
     $this->testResults = $results;
 
     $console = PhutilConsole::getConsole();
 
     $output_format = $this->getOutputFormat();
 
     if ($output_format !== 'full') {
       $console->disableOut();
     }
 
     $unresolved = array();
     $coverage = array();
     $postponed_count = 0;
     foreach ($results as $result) {
       $result_code = $result->getResult();
       if ($result_code == ArcanistUnitTestResult::RESULT_POSTPONED) {
         $postponed_count++;
         $unresolved[] = $result;
       } else {
         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 ($postponed_count) {
       $console->writeOut(
         '%s',
         $renderer->renderPostponedResult($postponed_count));
     }
 
     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__COVERAGE REPORT__\n");
 
       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;
       } else if ($result_code == ArcanistUnitTestResult::RESULT_POSTPONED &&
                  $overall_result != self::RESULT_UNSOUND) {
         $overall_result = self::RESULT_POSTPONED;
       }
     }
 
     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;
     }
 
     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');
   }
+
 }
diff --git a/src/workflow/ArcanistUpgradeWorkflow.php b/src/workflow/ArcanistUpgradeWorkflow.php
index 296f8030..9a7eba2a 100644
--- a/src/workflow/ArcanistUpgradeWorkflow.php
+++ b/src/workflow/ArcanistUpgradeWorkflow.php
@@ -1,84 +1,82 @@
 <?php
 
 /**
  * Upgrade arcanist itself.
- *
- * @group workflow
  */
 final class ArcanistUpgradeWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'upgrade';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **upgrade**
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: cli
           Upgrade arcanist and libphutil to the latest versions.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array();
   }
 
   public function run() {
     $roots = array();
     $roots['libphutil'] = dirname(phutil_get_library_root('phutil'));
     $roots['arcanist'] = dirname(phutil_get_library_root('arcanist'));
 
     foreach ($roots as $lib => $root) {
       echo "Upgrading {$lib}...\n";
 
       if (!Filesystem::pathExists($root.'/.git')) {
         throw new ArcanistUsageException(
           "{$lib} must be in its git working copy to be automatically ".
           "upgraded. This copy of {$lib} (in '{$root}') is not in a git ".
           "working copy.");
       }
 
       $working_copy = ArcanistWorkingCopyIdentity::newFromPath($root);
 
       $configuration_manager = clone $this->getConfigurationManager();
       $configuration_manager->setWorkingCopyIdentity($working_copy);
       $repository_api = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
         $configuration_manager);
 
       $this->setRepositoryAPI($repository_api);
 
       // Require no local changes.
       $this->requireCleanWorkingCopy();
 
       // Require the library be on master.
       $branch_name = $repository_api->getBranchName();
       if ($branch_name != 'master') {
         throw new ArcanistUsageException(
           "{$lib} must be on branch 'master' to be automatically upgraded. ".
           "This copy of {$lib} (in '{$root}') is on branch '{$branch_name}'.");
       }
 
       chdir($root);
       try {
         phutil_passthru('git pull --rebase');
       } catch (Exception $ex) {
         phutil_passthru('git rebase --abort');
         throw $ex;
       }
     }
 
     echo phutil_console_wrap(
       phutil_console_format(
         "**Updated!** Your copy of arc is now up to date.\n"));
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistUploadWorkflow.php b/src/workflow/ArcanistUploadWorkflow.php
index 60cbd5fc..7856c391 100644
--- a/src/workflow/ArcanistUploadWorkflow.php
+++ b/src/workflow/ArcanistUploadWorkflow.php
@@ -1,109 +1,106 @@
 <?php
 
 /**
  * Upload a file to Phabricator.
- *
- * @group workflow
  */
 final class ArcanistUploadWorkflow extends ArcanistBaseWorkflow {
 
   private $paths;
   private $json;
 
   public function getWorkflowName() {
     return 'upload';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **upload** __file__ [__file__ ...] [--json]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: filesystems
           Upload a file from local disk.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'json' => array(
         'help' => 'Output upload information in JSON format.',
       ),
       '*' => 'paths',
     );
   }
 
   protected function didParseArguments() {
     if (!$this->getArgument('paths')) {
       throw new ArcanistUsageException('Specify one or more files to upload.');
     }
 
     $this->paths = $this->getArgument('paths');
     $this->json = $this->getArgument('json');
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   private function getPaths() {
     return $this->paths;
   }
 
   private function getJSON() {
     return $this->json;
   }
 
   public function run() {
-
     $conduit = $this->getConduit();
 
     $results = array();
 
     foreach ($this->paths as $path) {
       $name = basename($path);
       $this->writeStatusMessage("Uploading '{$name}'...\n");
       try {
         $data = Filesystem::readFile($path);
       } catch (FilesystemException $ex) {
         $this->writeStatusMessage(
           "Unable to upload file: ".$ex->getMessage()."\n");
         $results[$path] = null;
         continue;
       }
 
       $phid = $conduit->callMethodSynchronous(
         'file.upload',
         array(
           'data_base64' => base64_encode($data),
           'name'        => $name,
         ));
       $info = $conduit->callMethodSynchronous(
         'file.info',
         array(
           'phid'        => $phid,
         ));
 
       $results[$path] = $info;
 
       if (!$this->getJSON()) {
         $id = $info['id'];
         echo "  F{$id} {$name}: ".$info['uri']."\n\n";
       }
     }
 
     if ($this->getJSON()) {
       echo json_encode($results)."\n";
     } else {
       $this->writeStatusMessage("Done.\n");
     }
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistWhichWorkflow.php b/src/workflow/ArcanistWhichWorkflow.php
index 9f8a62a8..aacda9f0 100644
--- a/src/workflow/ArcanistWhichWorkflow.php
+++ b/src/workflow/ArcanistWhichWorkflow.php
@@ -1,272 +1,271 @@
 <?php
 
 /**
  * Show which revision or revisions are in the working copy.
  */
 final class ArcanistWhichWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'which';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **which** [options] (svn)
       **which** [options] [__commit__] (hg, git)
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: svn, git, hg
           Shows which repository the current working copy corresponds to,
           which commits 'arc diff' will select, and which revision is in
           the working copy (or which revisions, if more than one matches).
 EOTEXT
       );
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function getArguments() {
     return array(
       'any-status' => array(
         'help' => 'Show committed and abandoned revisions.',
       ),
       'base' => array(
         'param' => 'rules',
         'help'  => 'Additional rules for determining base revision.',
         'nosupport' => array(
           'svn' => 'Subversion does not use base commits.',
         ),
         'supports' => array('git', 'hg'),
       ),
       'show-base' => array(
         'help'  => 'Print base commit only and exit.',
         'nosupport' => array(
           'svn' => 'Subversion does not use base commits.',
         ),
         'supports' => array('git', 'hg'),
       ),
       'head' => array(
         'param' => 'commit',
         'help' => pht('Specify the end of the commit range to select.'),
         'nosupport' => array(
           'svn' => pht('Subversion does not support commit ranges.'),
           'hg' => pht('Mercurial does not support --head yet.'),
         ),
         'supports' => array('git'),
       ),
       '*' => 'commit',
     );
   }
 
   public function run() {
-
     $console = PhutilConsole::getConsole();
 
     $this->printRepositorySection();
     $console->writeOut("\n");
 
     $repository_api = $this->getRepositoryAPI();
 
     $arg_commit = $this->getArgument('commit');
     if (count($arg_commit)) {
       $this->parseBaseCommitArgument($arg_commit);
     }
     $arg = $arg_commit ? ' '.head($arg_commit) : '';
 
     $repository_api->setBaseCommitArgumentRules(
       $this->getArgument('base', ''));
 
     $supports_ranges = $repository_api->supportsCommitRanges();
 
     $head_commit = $this->getArgument('head');
     if ($head_commit !== null) {
       $arg .= csprintf(' --head %R', $head_commit);
       $repository_api->setHeadCommit($head_commit);
     }
 
     if ($supports_ranges) {
       $relative = $repository_api->getBaseCommit();
 
       if ($this->getArgument('show-base')) {
         echo $relative."\n";
         return 0;
       }
 
       $info = $repository_api->getLocalCommitInformation();
       if ($info) {
         $commits = array();
         foreach ($info as $commit) {
           $hash     = substr($commit['commit'], 0, 16);
           $summary  = $commit['summary'];
 
           $commits[] = "    {$hash}  {$summary}";
         }
         $commits = implode("\n", $commits);
       } else {
         $commits = '    (No commits.)';
       }
 
       $explanation = $repository_api->getBaseCommitExplanation();
 
       $relative_summary = $repository_api->getCommitSummary($relative);
       $relative = substr($relative, 0, 16);
 
       if ($repository_api instanceof ArcanistGitAPI) {
         $head = $this->getArgument('head', 'HEAD');
         $command = csprintf('git diff %R', "{$relative}..{$head}");
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
         $command = csprintf(
           'hg diff --rev %R',
           hgsprintf('%s', $relative));
       } else {
         throw new Exception('Unknown VCS!');
       }
 
       echo phutil_console_wrap(
         phutil_console_format(
           "**COMMIT RANGE**\n".
           "If you run 'arc diff{$arg}', changes between the commit:\n\n"));
 
       echo  "    {$relative}  {$relative_summary}\n\n";
 
       if ($head_commit === null) {
         $will_be_sent = pht(
           '...and the current working copy state will be sent to '.
           'Differential, because %s',
           $explanation);
       } else {
         $will_be_sent = pht(
           '...and "%s" will be sent to Differential, because %s',
           $head_commit,
           $explanation);
       }
 
       echo phutil_console_wrap(
         "{$will_be_sent}\n\n".
         "You can see the exact changes that will be sent by running ".
         "this command:\n\n".
         "    $ {$command}\n\n".
         "These commits will be included in the diff:\n\n");
 
       echo $commits."\n\n\n";
     }
 
     $any_status = $this->getArgument('any-status');
 
     $query = array(
       'status' => $any_status
         ? 'status-any'
         : 'status-open',
     );
 
     $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
       $this->getConduit(),
       $query);
 
     echo phutil_console_wrap(
       phutil_console_format(
         "**MATCHING REVISIONS**\n".
         "These Differential revisions match the changes in this working ".
         "copy:\n\n"));
 
     if (empty($revisions)) {
       echo "    (No revisions match.)\n";
       echo "\n";
       echo phutil_console_wrap(
         phutil_console_format(
           "Since there are no revisions in Differential which match this ".
           "working copy, a new revision will be **created** if you run ".
           "'arc diff{$arg}'.\n\n"));
     } else {
       $other_author_phids = array();
       foreach ($revisions as $revision) {
         if ($revision['authorPHID'] != $this->getUserPHID()) {
           $other_author_phids[] = $revision['authorPHID'];
         }
       }
 
       $other_authors = array();
       if ($other_author_phids) {
         $other_authors = $this->getConduit()->callMethodSynchronous(
           'user.query',
           array(
             'phids' => $other_author_phids,
           ));
         $other_authors = ipull($other_authors, 'userName', 'phid');
       }
 
       foreach ($revisions as $revision) {
         $title = $revision['title'];
         $monogram = 'D'.$revision['id'];
 
         if ($revision['authorPHID'] != $this->getUserPHID()) {
           $author = $other_authors[$revision['authorPHID']];
           echo pht("    %s (%s) %s\n", $monogram, $author, $title);
         } else {
           echo pht("    %s %s\n", $monogram, $title);
         }
 
         echo '        Reason: '.$revision['why']."\n";
         echo "\n";
       }
       if (count($revisions) == 1) {
         echo phutil_console_wrap(
           phutil_console_format(
             "Since exactly one revision in Differential matches this working ".
             "copy, it will be **updated** if you run 'arc diff{$arg}'."));
       } else {
         echo phutil_console_wrap(
           "Since more than one revision in Differential matches this working ".
           "copy, you will be asked which revision you want to update if ".
           "you run 'arc diff {$arg}'.");
       }
       echo "\n\n";
     }
 
     return 0;
   }
 
   private function printRepositorySection() {
     $console = PhutilConsole::getConsole();
     $console->writeOut("**%s**\n", pht('REPOSITORY'));
 
     $callsign = $this->getRepositoryCallsign();
 
     $console->writeOut(
       "%s\n\n",
       pht(
         'To identify the repository associated with this working copy, '.
         'arc followed this process:'));
 
     foreach ($this->getRepositoryReasons() as $reason) {
       $reason = phutil_console_wrap($reason, 4);
       $console->writeOut("%s\n\n", $reason);
     }
 
     if ($callsign) {
       $console->writeOut(
         "%s\n",
         pht('This working copy is associated with the %s repository.',
         phutil_console_format('**%s**', $callsign)));
     } else {
       $console->writeOut(
         "%s\n",
         pht('This working copy is not associated with any repository.'));
     }
   }
 
 }
diff --git a/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php b/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
index 289f11a4..7ddd3feb 100644
--- a/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
+++ b/src/workingcopyidentity/ArcanistWorkingCopyIdentity.php
@@ -1,351 +1,348 @@
 <?php
 
 /**
  * Interfaces with basic information about the working copy.
  *
- *
  * @task config
- *
- * @group workingcopy
  */
 final class ArcanistWorkingCopyIdentity {
 
   private $projectConfig;
   private $projectRoot;
   private $localConfig = array();
   private $localMetaDir;
   private $vcsType;
   private $vcsRoot;
 
   public static function newDummyWorkingCopy() {
     return self::newFromPathWithConfig('/', array());
   }
 
   public static function newFromPath($path) {
     return self::newFromPathWithConfig($path, null);
   }
 
   /**
    * Locate all the information we need about a directory which we presume
    * to be a working copy. Particularly, we want to discover:
    *
    *   - Is the directory inside a working copy (hg, git, svn)?
    *   - If so, what is the root of the working copy?
    *   - Is there a `.arcconfig` file?
    *
    * This is complicated, mostly because Subversion has special rules. In
    * particular:
    *
    *   - Until 1.7, Subversion put a `.svn/` directory inside //every//
    *     directory in a working copy. After 1.7, it //only// puts one at the
    *     root.
    *   - We allow `.arcconfig` to appear anywhere in a Subversion working copy,
    *     and use the one closest to the directory.
    *   - Although we may use a `.arcconfig` from a subdirectory, we store
    *     metadata in the root's `.svn/`, because it's the only one guaranteed
    *     to exist.
    *
    * Users also do these kinds of things in the wild:
    *
    *   - Put working copies inside other working copies.
    *   - Put working copies inside `.git/` directories.
    *   - Create `.arcconfig` files at `/.arcconfig`, `/home/.arcconfig`, etc.
    *
    * This method attempts to be robust against all sorts of possible
    * misconfiguration.
    *
    * @param string    Path to load information for, usually the current working
    *                  directory (unless running unit tests).
    * @param map|null  Pass `null` to locate and load a `.arcconfig` file if one
    *                  exists. Pass a map to use it to set configuration.
    * @return ArcanistWorkingCopyIdentity Constructed working copy identity.
    */
   private static function newFromPathWithConfig($path, $config) {
     $project_root = null;
     $vcs_root = null;
     $vcs_type = null;
 
     // First, find the outermost directory which is a Git, Mercurial or
     // Subversion repository, if one exists. We go from the top because this
     // makes it easier to identify the root of old SVN working copies (which
     // have a ".svn/" directory inside every directory in the working copy) and
     // gives us the right result if you have a Git repository inside a
     // Subversion repository or something equally ridiculous.
 
     $paths = Filesystem::walkToRoot($path);
     $config_paths = array();
     $paths = array_reverse($paths);
     foreach ($paths as $path_key => $parent_path) {
       $try = array(
         'git' => $parent_path.'/.git',
         'hg'  => $parent_path.'/.hg',
         'svn' => $parent_path.'/.svn',
       );
 
       foreach ($try as $vcs => $try_dir) {
         if (!Filesystem::pathExists($try_dir)) {
           continue;
         }
 
         // NOTE: We're distinguishing between the `$project_root` and the
         // `$vcs_root` because they may not be the same in Subversion. Normally,
         // they are identical. However, in Subversion, the `$vcs_root` is the
         // base directory of the working copy (the directory which has the
         // `.svn/` directory, after SVN 1.7), while the `$project_root` might
         // be any subdirectory of the `$vcs_root`: it's the the directory
         // closest to the current directory which contains a `.arcconfig`.
 
         $project_root = $parent_path;
         $vcs_root = $parent_path;
         $vcs_type = $vcs;
         if ($vcs == 'svn') {
           // For Subversion, we'll look for a ".arcconfig" file here or in
           // any subdirectory, starting at the deepest subdirectory.
           $config_paths = array_slice($paths, $path_key);
           $config_paths = array_reverse($config_paths);
         } else {
           // For Git and Mercurial, we'll only look for ".arcconfig" right here.
           $config_paths = array($parent_path);
         }
         break;
       }
     }
 
     $console = PhutilConsole::getConsole();
 
     $looked_in = array();
     foreach ($config_paths as $config_path) {
       $config_file = $config_path.'/.arcconfig';
       $looked_in[] = $config_file;
       if (Filesystem::pathExists($config_file)) {
         // We always need to examine the filesystem to look for `.arcconfig`
         // so we can set the project root correctly. We might or might not
         // actually read the file: if the caller passed in configuration data,
         // we'll ignore the actual file contents.
         $project_root = $config_path;
         if ($config === null) {
           $console->writeLog(
             "%s\n",
             pht('Working Copy: Reading .arcconfig from "%s".', $config_file));
           $config_data = Filesystem::readFile($config_file);
           $config = self::parseRawConfigFile($config_data, $config_file);
         }
         break;
       }
     }
 
     if ($config === null) {
       if ($looked_in) {
         $console->writeLog(
           "%s\n",
           pht(
             'Working Copy: Unable to find .arcconfig in any of these '.
             'locations: %s.',
             implode(', ', $looked_in)));
       } else {
         $console->writeLog(
           "%s\n",
           pht(
             'Working Copy: No candidate locations for .arcconfig from '.
             'this working directory.'));
       }
       $config = array();
     }
 
     if ($project_root === null) {
       // We aren't in a working directory at all. This is fine if we're
       // running a command like "arc help". If we're running something that
       // requires a working directory, an exception will be raised a little
       // later on.
       $console->writeLog(
         "%s\n",
         pht('Working Copy: Path "%s" is not in any working copy.', $path));
       return new ArcanistWorkingCopyIdentity($path, $config);
     }
 
     $console->writeLog(
       "%s\n",
       pht(
         'Working Copy: Path "%s" is part of `%s` working copy "%s".',
         $path,
         $vcs_type,
         $vcs_root));
 
     $console->writeLog(
       "%s\n",
       pht(
         'Working Copy: Project root is at "%s".',
         $project_root));
 
     $identity = new ArcanistWorkingCopyIdentity($project_root, $config);
     $identity->localMetaDir = $vcs_root.'/.'.$vcs_type;
     $identity->localConfig = $identity->readLocalArcConfig();
     $identity->vcsType = $vcs_type;
     $identity->vcsRoot = $vcs_root;
 
     return $identity;
   }
 
   public static function newFromRootAndConfigFile(
     $root,
     $config_raw,
     $from_where) {
 
     if ($config_raw === null) {
       $config = array();
     } else {
       $config = self::parseRawConfigFile($config_raw, $from_where);
     }
 
     return self::newFromPathWithConfig($root, $config);
   }
 
   private static function parseRawConfigFile($raw_config, $from_where) {
     try {
       return phutil_json_decode($raw_config);
     } catch (PhutilJSONParserException $ex) {
       throw new PhutilProxyException(
         pht("Unable to parse '.arcconfig' file '%s'.", $from_where),
         $ex);
     }
   }
 
   private function __construct($root, array $config) {
     $this->projectRoot = $root;
     $this->projectConfig = $config;
   }
 
   public function getProjectID() {
     $project_id = $this->getProjectConfig('project.name');
     if ($project_id) {
       return $project_id;
     }
 
     // This is an older name for the setting.
     return $this->getProjectConfig('project_id');
   }
 
   public function getProjectRoot() {
     return $this->projectRoot;
   }
 
   public function getProjectPath($to_file) {
     return $this->projectRoot.'/'.$to_file;
   }
 
   public function getVCSType() {
     return $this->vcsType;
   }
 
   public function getVCSRoot() {
     return $this->vcsRoot;
   }
 
 
 /* -(  Config  )------------------------------------------------------------- */
 
   public function readProjectConfig() {
     return $this->projectConfig;
   }
 
   /**
    * Read a configuration directive from project configuration. This reads ONLY
    * permanent project configuration (i.e., ".arcconfig"), not other
    * configuration sources. See @{method:getConfigFromAnySource} to read from
    * user configuration.
    *
    * @param key   Key to read.
    * @param wild  Default value if key is not found.
    * @return wild Value, or default value if not found.
    *
    * @task config
    */
   public function getProjectConfig($key, $default = null) {
     $settings = new ArcanistSettings();
 
     $pval = idx($this->projectConfig, $key);
 
     // Test for older names in the per-project config only, since
     // they've only been used there.
     if ($pval === null) {
       $legacy = $settings->getLegacyName($key);
       if ($legacy) {
         $pval = $this->getProjectConfig($legacy);
       }
     }
 
     if ($pval === null) {
       $pval = $default;
     } else {
       $pval = $settings->willReadValue($key, $pval);
     }
 
     return $pval;
   }
 
   /**
-   * Read a configuration directive from local configuration.  This
+   * Read a configuration directive from local configuration. This
    * reads ONLY the per-working copy configuration,
    * i.e. .(git|hg|svn)/arc/config, and not other configuration
-   * sources.  See @{method:getConfigFromAnySource} to read from any
+   * sources. See @{method:getConfigFromAnySource} to read from any
    * config source or @{method:getProjectConfig} to read permanent
    * project-level config.
    *
    * @task config
    */
   public function getLocalConfig($key, $default = null) {
     return idx($this->localConfig, $key, $default);
   }
 
   public function readLocalArcConfig() {
     if (strlen($this->localMetaDir)) {
       $local_path = Filesystem::resolvePath('arc/config', $this->localMetaDir);
 
       $console = PhutilConsole::getConsole();
 
       if (Filesystem::pathExists($local_path)) {
         $console->writeLog(
           "%s\n",
           pht(
             'Config: Reading local configuration file "%s"...',
             $local_path));
 
         try {
           $json = Filesystem::readFile($local_path);
           return phutil_json_decode($json);
         } catch (PhutilJSONParserException $ex) {
           throw new PhutilProxyException(
             pht("Failed to parse '%s' as JSON.", $local_path),
             $ex);
         }
       } else {
         $console->writeLog(
           "%s\n",
           pht(
             'Config: Did not find local configuration at "%s".',
             $local_path));
       }
     }
 
     return array();
   }
 
   public function writeLocalArcConfig(array $config) {
     $json_encoder = new PhutilJSON();
     $json = $json_encoder->encodeFormatted($config);
 
     $dir = $this->localMetaDir;
     if (!strlen($dir)) {
       throw new Exception(pht('No working copy to write config into!'));
     }
 
     $local_dir = $dir.DIRECTORY_SEPARATOR.'arc';
     if (!Filesystem::pathExists($local_dir)) {
       Filesystem::createDirectory($local_dir, 0755);
     }
 
     $config_file = $local_dir.DIRECTORY_SEPARATOR.'config';
     Filesystem::writeFile($config_file, $json);
   }
 
 }