diff --git a/scripts/arcanist.php b/scripts/arcanist.php
index af296a11..f0723caa 100755
--- a/scripts/arcanist.php
+++ b/scripts/arcanist.php
@@ -1,698 +1,708 @@
 #!/usr/bin/env php
 <?php
 
 sanity_check_environment();
 
 require_once dirname(__FILE__).'/__init_script__.php';
 
 /**
  * Adjust 'include_path' to add locations where we'll search for libraries.
  * We look in these places:
  *
  *  - Next to 'arcanist/'.
  *  - Anywhere in the normal PHP 'include_path'.
  *  - Inside 'arcanist/externals/includes/'.
  */
 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();
 
 ini_set('memory_limit', -1);
 
 $original_argv = $argv;
 $base_args = new PhutilArgumentParser($argv);
 $base_args->parseStandardArguments();
 $base_args->parsePartial(
   array(
     array(
       'name'    => 'load-phutil-library',
       'param'   => 'path',
       'help'    => pht('Load a libphutil library.'),
       'repeat'  => true,
     ),
     array(
       'name'    => 'library',
       'param'   => 'path',
       'help'    => pht('Load a library (same as --load-phutil-library).'),
       'repeat'  => true,
     ),
     array(
       'name'    => 'arcrc-file',
       'param'   => 'filename',
     ),
     array(
       'name'    => 'conduit-uri',
       'param'   => 'uri',
-      'help'    => pht('Connect to Phabricator install specified by __uri__.'),
+      'help'    => pht(
+        'Connect to the %s (or compatible software) server specified by '.
+        '__uri__.',
+        PlatformSymbols::getPlatformServerName()),
     ),
     array(
       'name' => 'conduit-token',
       'param' => 'token',
       'help' => pht('Use a specific authentication token.'),
     ),
     array(
       'name' => 'anonymous',
       'help' => pht('Run workflow as a public user, without authenticating.'),
     ),
     array(
       'name'   => 'config',
       'param'  => 'key=value',
       'repeat' => true,
       'help'   => pht(
         'Specify a runtime configuration value. This will take precedence '.
-        'over static values, and only affect the current arcanist invocation.'),
+        'over static values, and only affect the current process: the '.
+        'setting is not saved anywhere.'),
     ),
 ));
 
 $config_trace_mode = $base_args->getArg('trace');
 
 $force_conduit = $base_args->getArg('conduit-uri');
 $force_token = $base_args->getArg('conduit-token');
 $custom_arcrc = $base_args->getArg('arcrc-file');
 $is_anonymous = $base_args->getArg('anonymous');
 $load = array_merge(
   $base_args->getArg('load-phutil-library'),
   $base_args->getArg('library'));
 $help = $base_args->getArg('help');
 $args = array_values($base_args->getUnconsumedArgumentVector());
 
 $working_directory = getcwd();
 $console = PhutilConsole::getConsole();
 $config = null;
 $workflow = null;
 
 try {
   if ($config_trace_mode) {
     echo tsprintf(
       "**<bg:magenta> %s </bg>** %s\n",
       pht('ARGV'),
       csprintf('%Ls', $original_argv));
 
     $libraries = array(
       'arcanist',
     );
 
     foreach ($libraries as $library_name) {
       echo tsprintf(
         "**<bg:magenta> %s </bg>** %s\n",
         pht('LOAD'),
         pht(
           'Loaded "%s" from "%s".',
           $library_name,
           phutil_get_library_root($library_name)));
     }
   }
 
   if (!$args) {
     if ($help) {
       $args = array('help');
     } else {
       throw new ArcanistUsageException(
         pht('No command provided. Try `%s`.', 'arc help'));
     }
   } else if ($help) {
     array_unshift($args, 'help');
   }
 
   $configuration_manager = new ArcanistConfigurationManager();
   if ($custom_arcrc) {
     $configuration_manager->setUserConfigurationFileLocation($custom_arcrc);
   }
 
   $global_config = $configuration_manager->readUserArcConfig();
   $system_config = $configuration_manager->readSystemArcConfig();
   $runtime_config = $configuration_manager->applyRuntimeArcConfig($base_args);
 
   $working_copy =
     ArcanistWorkingCopyIdentity::newFromPath($working_directory);
   $configuration_manager->setWorkingCopyIdentity($working_copy);
 
   // Load additional libraries, which can provide new classes like configuration
   // overrides, linters and lint engines, unit test engines, etc.
 
   // If the user specified "--load-phutil-library" one or more times from
   // the command line, we load those libraries **instead** of whatever else
   // is configured. This is basically a debugging feature to let you force
   // specific libraries to load regardless of the state of the world.
   if ($load) {
     $console->writeLog(
       "%s\n",
       pht(
         'Using `%s` flag, configuration will be ignored and configured '.
         'libraries will not be loaded.',
         '--load-phutil-library'));
     // Load the flag libraries. These must load, since the user specified them
     // explicitly.
     arcanist_load_libraries(
       $load,
       $must_load = true,
       $lib_source = pht('a "%s" flag', '--load-phutil-library'),
       $working_copy);
   } else {
     // Load libraries in system 'load' config. In contrast to global config, we
     // fail hard here because this file is edited manually, so if 'arc' breaks
     // that doesn't make it any more difficult to correct.
     arcanist_load_libraries(
       idx($system_config, 'load', array()),
       $must_load = true,
       $lib_source = pht('the "%s" setting in system config', 'load'),
       $working_copy);
 
     // Load libraries in global 'load' config, as per "arc set-config load". We
     // need to fail softly if these break because errors would prevent the user
     // from running "arc set-config" to correct them.
     arcanist_load_libraries(
       idx($global_config, 'load', array()),
       $must_load = false,
       $lib_source = pht('the "%s" setting in global config', 'load'),
       $working_copy);
 
     // Load libraries in ".arcconfig". Libraries here must load.
     arcanist_load_libraries(
       $working_copy->getProjectConfig('load'),
       $must_load = true,
       $lib_source = pht('the "%s" setting in "%s"', 'load', '.arcconfig'),
       $working_copy);
 
     // Load libraries in ".arcconfig". Libraries here must load.
     arcanist_load_libraries(
       idx($runtime_config, 'load', array()),
       $must_load = true,
       $lib_source = pht('the %s argument', '--config "load=[...]"'),
       $working_copy);
   }
 
   $user_config = $configuration_manager->readUserConfigurationFile();
   $config = new ArcanistConfiguration();
 
   $command = strtolower($args[0]);
   $args = array_slice($args, 1);
   $workflow = $config->selectWorkflow(
     $command,
     $args,
     $configuration_manager,
     $console);
   $workflow->setConfigurationManager($configuration_manager);
   $workflow->setArcanistConfiguration($config);
   $workflow->setCommand($command);
   $workflow->setWorkingDirectory($working_directory);
   $workflow->parseArguments($args);
 
   // Write the command into the environment so that scripts (for example, local
   // Git commit hooks) can detect that they're being run via `arc` and change
   // their behaviors.
   putenv('ARCANIST='.$command);
 
   $need_working_copy = $workflow->requiresWorkingCopy();
 
   $supported_vcs_types = $workflow->getSupportedRevisionControlSystems();
   $vcs_type = $working_copy->getVCSType();
   if ($vcs_type || $need_working_copy) {
     if (!in_array($vcs_type, $supported_vcs_types)) {
       throw new ArcanistUsageException(
         pht(
           '`%s %s` is only supported under %s.',
           'arc',
           $workflow->getWorkflowName(),
           implode(', ', $supported_vcs_types)));
     }
   }
 
   $need_conduit         = $workflow->requiresConduit();
   $need_auth            = $workflow->requiresAuthentication();
   $need_repository_api  = $workflow->requiresRepositoryAPI();
 
   $want_repository_api = $workflow->desiresRepositoryAPI();
   $want_working_copy = $workflow->desiresWorkingCopy() ||
                        $want_repository_api;
 
   $need_conduit       = $need_conduit ||
                         $need_auth;
   $need_working_copy  = $need_working_copy ||
                         $need_repository_api;
 
   if ($need_working_copy || $want_working_copy) {
     if ($need_working_copy && !$working_copy->getVCSType()) {
       throw new ArcanistUsageException(
         pht(
           'This command must be run in a Git, Mercurial or Subversion '.
           'working copy.'));
     }
     $configuration_manager->setWorkingCopyIdentity($working_copy);
   }
 
   if ($force_conduit) {
     $conduit_uri = $force_conduit;
   } else {
     $conduit_uri = $configuration_manager->getConfigFromAnySource(
       'phabricator.uri');
     if ($conduit_uri === null) {
       $conduit_uri = $configuration_manager->getConfigFromAnySource('default');
     }
   }
 
   if ($conduit_uri) {
     // Set the URI path to '/api/'. TODO: Originally, I contemplated letting
     // you deploy Phabricator somewhere other than the domain root, but ended
     // up never pursuing that. We should get rid of all "/api/" silliness
     // in things users are expected to configure. This is already happening
     // to some degree, e.g. "arc install-certificate" does it for you.
     $conduit_uri = new PhutilURI($conduit_uri);
     $conduit_uri->setPath('/api/');
     $conduit_uri = (string)$conduit_uri;
   }
   $workflow->setConduitURI($conduit_uri);
 
   // Apply global CA bundle from configs.
   $ca_bundle = $configuration_manager->getConfigFromAnySource('https.cabundle');
   if ($ca_bundle) {
     $ca_bundle = Filesystem::resolvePath(
       $ca_bundle, $working_copy->getProjectRoot());
     HTTPSFuture::setGlobalCABundleFromPath($ca_bundle);
   }
 
   $blind_key = 'https.blindly-trust-domains';
   $blind_trust = $configuration_manager->getConfigFromAnySource($blind_key);
   if ($blind_trust) {
     $trust_extension = PhutilHTTPEngineExtension::requireExtension(
       ArcanistBlindlyTrustHTTPEngineExtension::EXTENSIONKEY);
     $trust_extension->setDomains($blind_trust);
   }
 
   if ($need_conduit) {
     if (!$conduit_uri) {
 
       $message = phutil_console_format(
         "%s\n\n  - %s\n  - %s\n  - %s\n",
         pht(
-          'This command requires arc to connect to a Phabricator install, '.
-          'but no Phabricator installation is configured. To configure a '.
-          'Phabricator URI:'),
+          'This command requires %s to connect to a %s (or compatible '.
+          'software) server, but no %s server is configured. To configure a '.
+          '%s server URI:',
+          PlatformSymbols::getPlatformClientName(),
+          PlatformSymbols::getPlatformServerName(),
+          PlatformSymbols::getPlatformServerName(),
+          PlatformSymbols::getPlatformServerName()),
         pht(
           'set a default location with `%s`; or',
           'arc set-config default <uri>'),
         pht(
           'specify `%s` explicitly; or',
           '--conduit-uri=uri'),
         pht(
           "run `%s` in a working copy with an '%s'.",
           'arc',
           '.arcconfig'));
 
       $message = phutil_console_wrap($message);
       throw new ArcanistUsageException($message);
     }
     $workflow->establishConduit();
   }
 
   $hosts_config = idx($user_config, 'hosts', array());
   $host_config = idx($hosts_config, $conduit_uri, array());
   $user_name = idx($host_config, 'user');
   $certificate = idx($host_config, 'cert');
   $conduit_token = idx($host_config, 'token');
   if ($force_token) {
     $conduit_token = $force_token;
   }
 
   if ($is_anonymous) {
     $conduit_token = null;
   }
 
   $description = implode(' ', $original_argv);
   $credentials = array(
     'user' => $user_name,
     'certificate' => $certificate,
     'description' => $description,
     'token' => $conduit_token,
   );
   $workflow->setConduitCredentials($credentials);
 
   $engine = id(new ArcanistConduitEngine())
     ->setConduitURI($conduit_uri)
     ->setConduitToken($conduit_token);
 
   $workflow->setConduitEngine($engine);
 
   if ($need_auth) {
     if ((!$user_name || !$certificate) && (!$conduit_token)) {
       $arc = 'arc';
       if ($force_conduit) {
         $arc .= csprintf(' --conduit-uri=%s', $conduit_uri);
       }
 
       $conduit_domain = id(new PhutilURI($conduit_uri))->getDomain();
 
       throw new ArcanistUsageException(
         phutil_console_format(
           "%s\n\n%s\n\n%s **%s:**\n\n      $ **{$arc} install-certificate**\n",
           pht('YOU NEED TO AUTHENTICATE TO CONTINUE'),
           pht(
             'You are trying to connect to a server (%s) that you '.
             'do not have any credentials stored for.',
             $conduit_domain),
           pht('To retrieve and store credentials for this server,'),
           pht('run this command')));
     }
     $workflow->authenticateConduit();
   }
 
   if ($need_repository_api ||
       ($want_repository_api && $working_copy->getVCSType())) {
     $repository_api = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
       $configuration_manager);
     $workflow->setRepositoryAPI($repository_api);
   }
 
   $listeners = $configuration_manager->getConfigFromAnySource(
     'events.listeners');
   if ($listeners) {
     foreach ($listeners as $listener) {
       $console->writeLog(
         "%s\n",
         pht("Registering event listener '%s'.", $listener));
       try {
         id(new $listener())->register();
       } catch (PhutilMissingSymbolException $ex) {
         // Continue anyway, since you may otherwise be unable to run commands
         // like `arc set-config events.listeners` in order to repair the damage
         // you've caused. We're writing out the entire exception here because
         // it might not have been triggered by the listener itself (for example,
         // the listener might use a bad class in its register() method).
         $console->writeErr(
           "%s\n",
           pht(
             "ERROR: Failed to load event listener '%s': %s",
             $listener,
             $ex->getMessage()));
       }
     }
   }
 
   $config->willRunWorkflow($command, $workflow);
   $workflow->willRunWorkflow();
   try {
     $err = $workflow->run();
     $config->didRunWorkflow($command, $workflow, $err);
   } catch (Exception $e) {
     $workflow->finalize();
     throw $e;
   }
   $workflow->finalize();
   exit((int)$err);
 
 } catch (ArcanistNoEffectException $ex) {
   echo $ex->getMessage()."\n";
 
 } catch (Exception $ex) {
   $is_usage = ($ex instanceof ArcanistUsageException);
   if ($is_usage) {
     fwrite(STDERR, phutil_console_format(
       "**%s** %s\n",
       pht('Usage Exception:'),
       rtrim($ex->getMessage())));
   }
 
   if ($config) {
     $config->didAbortWorkflow($command, $workflow, $ex);
   }
 
   if ($config_trace_mode) {
     fwrite(STDERR, "\n");
     throw $ex;
   }
 
   if (!$is_usage) {
     fwrite(STDERR, phutil_console_format(
       "<bg:red>** %s **</bg>\n", pht('Exception')));
 
     while ($ex) {
       fwrite(STDERR, $ex->getMessage()."\n");
 
       if ($ex instanceof PhutilProxyException) {
         $ex = $ex->getPreviousException();
       } else {
         $ex = null;
       }
     }
 
     fwrite(STDERR, phutil_console_format(
       "(%s)\n",
       pht('Run with `%s` for a full exception trace.', '--trace')));
   }
 
   exit(1);
 }
 
 
 /**
  * Perform some sanity checks against the possible diversity of PHP builds in
  * the wild, like very old versions and builds that were compiled with flags
  * that exclude core functionality.
  */
 function sanity_check_environment() {
   // NOTE: We don't have phutil_is_windows() yet here.
   $is_windows = (DIRECTORY_SEPARATOR != '/');
 
   // We use stream_socket_pair() which is not available on Windows earlier.
   $min_version = ($is_windows ? '5.3.0' : '5.2.3');
   $cur_version = phpversion();
   if (version_compare($cur_version, $min_version, '<')) {
     die_with_bad_php(
       "You are running PHP version '{$cur_version}', which is older than ".
       "the minimum version, '{$min_version}'. Update to at least ".
       "'{$min_version}'.");
   }
 
   if ($is_windows) {
     $need_functions = array(
       'curl_init'     => array('builtin-dll', 'php_curl.dll'),
     );
   } else {
     $need_functions = array(
       'curl_init'     => array(
         'text',
         "You need to install the cURL PHP extension, maybe with ".
         "'apt-get install php5-curl' or 'yum install php53-curl' or ".
         "something similar.",
       ),
       'json_decode'   => array('flag', '--without-json'),
     );
   }
 
   $problems = array();
 
   $config = null;
   $show_config = false;
   foreach ($need_functions as $fname => $resolution) {
     if (function_exists($fname)) {
       continue;
     }
 
     static $info;
     if ($info === null) {
       ob_start();
       phpinfo(INFO_GENERAL);
       $info = ob_get_clean();
       $matches = null;
       if (preg_match('/^Configure Command =>\s*(.*?)$/m', $info, $matches)) {
         $config = $matches[1];
       }
     }
 
     $generic = true;
     list($what, $which) = $resolution;
 
     if ($what == 'flag' && strpos($config, $which) !== false) {
       $show_config = true;
       $generic = false;
       $problems[] =
         "This build of PHP was compiled with the configure flag '{$which}', ".
         "which means it does not have the function '{$fname}()'. This ".
         "function is required for arc to run. Rebuild PHP without this flag. ".
         "You may also be able to build or install the relevant extension ".
         "separately.";
     }
 
     if ($what == 'builtin-dll') {
       $generic = false;
       $problems[] =
         "Your install of PHP does not have the '{$which}' extension enabled. ".
         "Edit your php.ini file and uncomment the line which reads ".
         "'extension={$which}'.";
     }
 
     if ($what == 'text') {
       $generic = false;
       $problems[] = $which;
     }
 
     if ($generic) {
       $problems[] =
         "This build of PHP is missing the required function '{$fname}()'. ".
         "Rebuild PHP or install the extension which provides '{$fname}()'.";
     }
   }
 
   if ($problems) {
     if ($show_config) {
       $problems[] = "PHP was built with this configure command:\n\n{$config}";
     }
     die_with_bad_php(implode("\n\n", $problems));
   }
 }
 
 function die_with_bad_php($message) {
   // NOTE: We're bailing because PHP is broken. We can't call any library
   // functions because they won't be loaded yet.
 
   echo "\n";
   echo 'PHP CONFIGURATION ERRORS';
   echo "\n\n";
   echo $message;
   echo "\n\n";
   exit(1);
 }
 
 function arcanist_load_libraries(
   $load,
   $must_load,
   $lib_source,
   ArcanistWorkingCopyIdentity $working_copy) {
 
   if (!$load) {
     return;
   }
 
   if (!is_array($load)) {
     $error = pht(
       'Libraries specified by %s are invalid; expected a list. '.
       'Check your configuration.',
       $lib_source);
     $console = PhutilConsole::getConsole();
     $console->writeErr("%s: %s\n", pht('WARNING'), $error);
     return;
   }
 
   foreach ($load as $location) {
 
     // Try to resolve the library location. We look in several places, in
     // order:
     //
     //  1. Inside the working copy. This is for phutil libraries within the
     //     project. For instance "library/src" will resolve to
     //     "./library/src" if it exists.
     //  2. In the same directory as the working copy. This allows you to
     //     check out a library alongside a working copy and reference it.
     //     If we haven't resolved yet, "library/src" will try to resolve to
     //     "../library/src" if it exists.
     //  3. Using normal libphutil resolution rules. Generally, this means
     //     that it checks for libraries next to libphutil, then libraries
     //     in the PHP include_path.
     //
     // Note that absolute paths will just resolve absolutely through rule (1).
 
     $resolved = false;
 
     // Check inside the working copy. This also checks absolute paths, since
     // they'll resolve absolute and just ignore the project root.
     $resolved_location = Filesystem::resolvePath(
       $location,
       $working_copy->getProjectRoot());
     if (Filesystem::pathExists($resolved_location)) {
       $location = $resolved_location;
       $resolved = true;
     }
 
     // If we didn't find anything, check alongside the working copy.
     if (!$resolved) {
       $resolved_location = Filesystem::resolvePath(
         $location,
         dirname($working_copy->getProjectRoot()));
       if (Filesystem::pathExists($resolved_location)) {
         $location = $resolved_location;
         $resolved = true;
       }
     }
 
     $console = PhutilConsole::getConsole();
     $console->writeLog(
       "%s\n",
       pht("Loading phutil library from '%s'...", $location));
 
     $error = null;
     try {
       phutil_load_library($location);
     } catch (PhutilBootloaderException $ex) {
       $error = pht(
         "Failed to load phutil library at location '%s'. This library ".
         "is specified by %s. Check that the setting is correct and the ".
         "library is located in the right place.",
         $location,
         $lib_source);
       if ($must_load) {
         throw new ArcanistUsageException($error);
       } else {
         fwrite(STDERR, phutil_console_wrap(
           phutil_console_format("%s: %s\n",
                                 pht('WARNING'),
                                 $error)));
       }
     } catch (PhutilLibraryConflictException $ex) {
       if ($ex->getLibrary() != 'arcanist') {
         throw $ex;
       }
 
       // NOTE: If you are running `arc` against itself, we ignore the library
       // conflict created by loading the local `arc` library (in the current
       // working directory) and continue without loading it.
 
       // This means we only execute code in the `arcanist/` directory which is
       // associated with the binary you are running, whereas we would normally
       // execute local code.
 
       // This can make `arc` development slightly confusing if your setup is
       // especially bizarre, but it allows `arc` to be used in automation
       // workflows more easily. For some context, see PHI13.
 
       $executing_directory = dirname(dirname(__FILE__));
       $working_directory = dirname($location);
 
       fwrite(
         STDERR,
         tsprintf(
           "**<bg:yellow> %s </bg>** %s\n",
           pht('VERY META'),
           pht(
-            'You are running one copy of Arcanist (at path "%s") against '.
-            'another copy of Arcanist (at path "%s"). Code in the current '.
+            'You are running one copy of %s (at path "%s") against '.
+            'another copy of %s (at path "%s"). Code in the current '.
             'working directory will not be loaded or executed.',
+            PlatformSymbols::getPlatformClientName(),
             $executing_directory,
+            PlatformSymbols::getPlatformClientName(),
             $working_directory)));
     }
   }
 }
diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
index 57cef3ab..a70e5cfe 100644
--- a/src/__phutil_library_map__.php
+++ b/src/__phutil_library_map__.php
@@ -1,2020 +1,2028 @@
 <?php
 
 /**
  * This file is automatically generated. Use 'arc liberate' to rebuild it.
  *
  * @generated
  * @phutil-library-version 2
  */
 phutil_register_library_map(array(
   '__library_version__' => 2,
   'class' => array(
     'AASTNode' => 'parser/aast/api/AASTNode.php',
     'AASTNodeList' => 'parser/aast/api/AASTNodeList.php',
     'AASTToken' => 'parser/aast/api/AASTToken.php',
     'AASTTree' => 'parser/aast/api/AASTTree.php',
     'AbstractDirectedGraph' => 'utils/AbstractDirectedGraph.php',
     'AbstractDirectedGraphTestCase' => 'utils/__tests__/AbstractDirectedGraphTestCase.php',
     'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAbstractMethodBodyXHPASTLinterRule.php',
     'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase.php',
     'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAbstractPrivateMethodXHPASTLinterRule.php',
     'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase.php',
     'ArcanistAlias' => 'toolset/ArcanistAlias.php',
     'ArcanistAliasEffect' => 'toolset/ArcanistAliasEffect.php',
     'ArcanistAliasEngine' => 'toolset/ArcanistAliasEngine.php',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAliasFunctionXHPASTLinterRule.php',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAliasFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistAliasWorkflow' => 'toolset/workflow/ArcanistAliasWorkflow.php',
     'ArcanistAliasesConfigOption' => 'config/option/ArcanistAliasesConfigOption.php',
     'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
     'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.php',
     'ArcanistArcConfigurationEngineExtension' => 'config/arc/ArcanistArcConfigurationEngineExtension.php',
     'ArcanistArcToolset' => 'toolset/ArcanistArcToolset.php',
     'ArcanistArcWorkflow' => 'toolset/workflow/ArcanistArcWorkflow.php',
     'ArcanistArrayCombineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayCombineXHPASTLinterRule.php',
     'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayCombineXHPASTLinterRuleTestCase.php',
     'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayIndexSpacingXHPASTLinterRule.php',
     'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistArraySeparatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArraySeparatorXHPASTLinterRule.php',
     'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArraySeparatorXHPASTLinterRuleTestCase.php',
     'ArcanistArrayValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayValueXHPASTLinterRule.php',
     'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayValueXHPASTLinterRuleTestCase.php',
     'ArcanistBaseCommitParser' => 'parser/ArcanistBaseCommitParser.php',
     'ArcanistBaseCommitParserTestCase' => 'parser/__tests__/ArcanistBaseCommitParserTestCase.php',
     'ArcanistBaseXHPASTLinter' => 'lint/linter/ArcanistBaseXHPASTLinter.php',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryExpressionSpacingXHPASTLinterRule.php',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryNumericScalarCasingXHPASTLinterRule.php',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase.php',
     'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBlacklistedFunctionXHPASTLinterRule.php',
     'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistBlindlyTrustHTTPEngineExtension' => 'configuration/ArcanistBlindlyTrustHTTPEngineExtension.php',
     'ArcanistBookmarksWorkflow' => 'workflow/ArcanistBookmarksWorkflow.php',
     'ArcanistBoolConfigOption' => 'config/option/ArcanistBoolConfigOption.php',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBraceFormattingXHPASTLinterRule.php',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBraceFormattingXHPASTLinterRuleTestCase.php',
     'ArcanistBranchesWorkflow' => 'workflow/ArcanistBranchesWorkflow.php',
     'ArcanistBrowseCommitHardpointQuery' => 'browse/query/ArcanistBrowseCommitHardpointQuery.php',
     'ArcanistBrowseCommitURIHardpointQuery' => 'browse/query/ArcanistBrowseCommitURIHardpointQuery.php',
     'ArcanistBrowseObjectNameURIHardpointQuery' => 'browse/query/ArcanistBrowseObjectNameURIHardpointQuery.php',
     'ArcanistBrowsePathURIHardpointQuery' => 'browse/query/ArcanistBrowsePathURIHardpointQuery.php',
     'ArcanistBrowseRef' => 'browse/ref/ArcanistBrowseRef.php',
     'ArcanistBrowseRefInspector' => 'inspector/ArcanistBrowseRefInspector.php',
     'ArcanistBrowseRevisionURIHardpointQuery' => 'browse/query/ArcanistBrowseRevisionURIHardpointQuery.php',
     'ArcanistBrowseURIHardpointQuery' => 'browse/query/ArcanistBrowseURIHardpointQuery.php',
     'ArcanistBrowseURIRef' => 'browse/ref/ArcanistBrowseURIRef.php',
     'ArcanistBrowseWorkflow' => 'browse/workflow/ArcanistBrowseWorkflow.php',
     'ArcanistBuildBuildplanHardpointQuery' => 'ref/build/ArcanistBuildBuildplanHardpointQuery.php',
     'ArcanistBuildPlanRef' => 'ref/buildplan/ArcanistBuildPlanRef.php',
     'ArcanistBuildPlanSymbolRef' => 'ref/buildplan/ArcanistBuildPlanSymbolRef.php',
     'ArcanistBuildRef' => 'ref/build/ArcanistBuildRef.php',
     'ArcanistBuildSymbolRef' => 'ref/build/ArcanistBuildSymbolRef.php',
     'ArcanistBuildableBuildsHardpointQuery' => 'ref/buildable/ArcanistBuildableBuildsHardpointQuery.php',
     'ArcanistBuildableRef' => 'ref/buildable/ArcanistBuildableRef.php',
     'ArcanistBuildableSymbolRef' => 'ref/buildable/ArcanistBuildableSymbolRef.php',
     'ArcanistBundle' => 'parser/ArcanistBundle.php',
     'ArcanistBundleTestCase' => 'parser/__tests__/ArcanistBundleTestCase.php',
     'ArcanistCSSLintLinter' => 'lint/linter/ArcanistCSSLintLinter.php',
     'ArcanistCSSLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCSSLintLinterTestCase.php',
     'ArcanistCSharpLinter' => 'lint/linter/ArcanistCSharpLinter.php',
     'ArcanistCallConduitWorkflow' => 'workflow/ArcanistCallConduitWorkflow.php',
     'ArcanistCallParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallParenthesesXHPASTLinterRule.php',
     'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallTimePassByReferenceXHPASTLinterRule.php',
     'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistCapabilityNotSupportedException' => 'workflow/exception/ArcanistCapabilityNotSupportedException.php',
     'ArcanistCastSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCastSpacingXHPASTLinterRule.php',
     'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCastSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistCheckstyleXMLLintRenderer' => 'lint/renderer/ArcanistCheckstyleXMLLintRenderer.php',
     'ArcanistChmodLinter' => 'lint/linter/ArcanistChmodLinter.php',
     'ArcanistChmodLinterTestCase' => 'lint/linter/__tests__/ArcanistChmodLinterTestCase.php',
     'ArcanistClassExtendsObjectXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassExtendsObjectXHPASTLinterRule.php',
     'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassExtendsObjectXHPASTLinterRuleTestCase.php',
     'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassFilenameMismatchXHPASTLinterRule.php',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule.php',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase.php',
     'ArcanistClassNameLiteralXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassNameLiteralXHPASTLinterRule.php',
     'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassNameLiteralXHPASTLinterRuleTestCase.php',
     'ArcanistCloseRevisionWorkflow' => 'workflow/ArcanistCloseRevisionWorkflow.php',
     'ArcanistClosureLinter' => 'lint/linter/ArcanistClosureLinter.php',
     'ArcanistClosureLinterTestCase' => 'lint/linter/__tests__/ArcanistClosureLinterTestCase.php',
     'ArcanistCoffeeLintLinter' => 'lint/linter/ArcanistCoffeeLintLinter.php',
     'ArcanistCoffeeLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCoffeeLintLinterTestCase.php',
     'ArcanistCommand' => 'toolset/command/ArcanistCommand.php',
     'ArcanistCommentRemover' => 'parser/ArcanistCommentRemover.php',
     'ArcanistCommentRemoverTestCase' => 'parser/__tests__/ArcanistCommentRemoverTestCase.php',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentSpacingXHPASTLinterRule.php',
     'ArcanistCommentStyleXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentStyleXHPASTLinterRule.php',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCommentStyleXHPASTLinterRuleTestCase.php',
     'ArcanistCommitGraph' => 'repository/graph/ArcanistCommitGraph.php',
     'ArcanistCommitGraphPartition' => 'repository/graph/ArcanistCommitGraphPartition.php',
     'ArcanistCommitGraphPartitionQuery' => 'repository/graph/ArcanistCommitGraphPartitionQuery.php',
     'ArcanistCommitGraphQuery' => 'repository/graph/query/ArcanistCommitGraphQuery.php',
     'ArcanistCommitGraphSet' => 'repository/graph/ArcanistCommitGraphSet.php',
     'ArcanistCommitGraphSetQuery' => 'repository/graph/ArcanistCommitGraphSetQuery.php',
     'ArcanistCommitGraphSetTreeView' => 'repository/graph/view/ArcanistCommitGraphSetTreeView.php',
     'ArcanistCommitGraphSetView' => 'repository/graph/view/ArcanistCommitGraphSetView.php',
     'ArcanistCommitGraphTestCase' => 'repository/graph/__tests__/ArcanistCommitGraphTestCase.php',
     'ArcanistCommitNode' => 'repository/graph/ArcanistCommitNode.php',
     'ArcanistCommitRef' => 'ref/commit/ArcanistCommitRef.php',
     'ArcanistCommitSymbolRef' => 'ref/commit/ArcanistCommitSymbolRef.php',
     'ArcanistCommitSymbolRefInspector' => 'ref/commit/ArcanistCommitSymbolRefInspector.php',
     'ArcanistCommitUpstreamHardpointQuery' => 'query/ArcanistCommitUpstreamHardpointQuery.php',
     'ArcanistCommitWorkflow' => 'workflow/ArcanistCommitWorkflow.php',
     'ArcanistCompilerLintRenderer' => 'lint/renderer/ArcanistCompilerLintRenderer.php',
     'ArcanistComposerLinter' => 'lint/linter/ArcanistComposerLinter.php',
     'ArcanistComprehensiveLintEngine' => 'lint/engine/ArcanistComprehensiveLintEngine.php',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConcatenationOperatorXHPASTLinterRule.php',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConcatenationOperatorXHPASTLinterRuleTestCase.php',
     'ArcanistConduitAuthenticationException' => 'exception/ArcanistConduitAuthenticationException.php',
     'ArcanistConduitCallFuture' => 'conduit/ArcanistConduitCallFuture.php',
     'ArcanistConduitEngine' => 'conduit/ArcanistConduitEngine.php',
     'ArcanistConduitException' => 'conduit/ArcanistConduitException.php',
     'ArcanistConfigOption' => 'config/option/ArcanistConfigOption.php',
     'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
     'ArcanistConfigurationDrivenLintEngine' => 'lint/engine/ArcanistConfigurationDrivenLintEngine.php',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'unit/engine/ArcanistConfigurationDrivenUnitTestEngine.php',
     'ArcanistConfigurationEngine' => 'config/ArcanistConfigurationEngine.php',
     'ArcanistConfigurationEngineExtension' => 'config/ArcanistConfigurationEngineExtension.php',
     'ArcanistConfigurationManager' => 'configuration/ArcanistConfigurationManager.php',
     'ArcanistConfigurationSource' => 'config/source/ArcanistConfigurationSource.php',
     'ArcanistConfigurationSourceList' => 'config/ArcanistConfigurationSourceList.php',
     'ArcanistConfigurationSourceValue' => 'config/ArcanistConfigurationSourceValue.php',
     'ArcanistConsoleLintRenderer' => 'lint/renderer/ArcanistConsoleLintRenderer.php',
     'ArcanistConsoleLintRendererTestCase' => 'lint/renderer/__tests__/ArcanistConsoleLintRendererTestCase.php',
     'ArcanistConstructorParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConstructorParenthesesXHPASTLinterRule.php',
     'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConstructorParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistContinueInsideSwitchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistContinueInsideSwitchXHPASTLinterRule.php',
     'ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase.php',
     'ArcanistControlStatementSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistControlStatementSpacingXHPASTLinterRule.php',
     'ArcanistControlStatementSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistControlStatementSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistCoverWorkflow' => 'workflow/ArcanistCoverWorkflow.php',
     'ArcanistCppcheckLinter' => 'lint/linter/ArcanistCppcheckLinter.php',
     'ArcanistCppcheckLinterTestCase' => 'lint/linter/__tests__/ArcanistCppcheckLinterTestCase.php',
     'ArcanistCpplintLinter' => 'lint/linter/ArcanistCpplintLinter.php',
     'ArcanistCpplintLinterTestCase' => 'lint/linter/__tests__/ArcanistCpplintLinterTestCase.php',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCurlyBraceArrayIndexXHPASTLinterRule.php',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase.php',
     'ArcanistDeclarationParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeclarationParenthesesXHPASTLinterRule.php',
     'ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistDefaultParametersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDefaultParametersXHPASTLinterRule.php',
     'ArcanistDefaultParametersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDefaultParametersXHPASTLinterRuleTestCase.php',
     'ArcanistDefaultsConfigurationSource' => 'config/source/ArcanistDefaultsConfigurationSource.php',
     'ArcanistDeprecationXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeprecationXHPASTLinterRule.php',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeprecationXHPASTLinterRuleTestCase.php',
     'ArcanistDictionaryConfigurationSource' => 'config/source/ArcanistDictionaryConfigurationSource.php',
     'ArcanistDiffByteSizeException' => 'exception/ArcanistDiffByteSizeException.php',
     'ArcanistDiffChange' => 'parser/diff/ArcanistDiffChange.php',
     'ArcanistDiffChangeType' => 'parser/diff/ArcanistDiffChangeType.php',
     'ArcanistDiffHunk' => 'parser/diff/ArcanistDiffHunk.php',
     'ArcanistDiffParser' => 'parser/ArcanistDiffParser.php',
     'ArcanistDiffParserTestCase' => 'parser/__tests__/ArcanistDiffParserTestCase.php',
     'ArcanistDiffUtils' => 'difference/ArcanistDiffUtils.php',
     'ArcanistDiffUtilsTestCase' => 'difference/__tests__/ArcanistDiffUtilsTestCase.php',
     'ArcanistDiffVectorNode' => 'difference/ArcanistDiffVectorNode.php',
     'ArcanistDiffVectorTree' => 'difference/ArcanistDiffVectorTree.php',
     'ArcanistDiffWorkflow' => 'workflow/ArcanistDiffWorkflow.php',
     'ArcanistDifferentialCommitMessage' => 'differential/ArcanistDifferentialCommitMessage.php',
     'ArcanistDifferentialCommitMessageParserException' => 'differential/ArcanistDifferentialCommitMessageParserException.php',
     'ArcanistDifferentialDependencyGraph' => 'differential/ArcanistDifferentialDependencyGraph.php',
     'ArcanistDifferentialRevisionHash' => 'differential/constants/ArcanistDifferentialRevisionHash.php',
     'ArcanistDifferentialRevisionStatus' => 'differential/constants/ArcanistDifferentialRevisionStatus.php',
     'ArcanistDoubleQuoteXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDoubleQuoteXHPASTLinterRule.php',
     'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDoubleQuoteXHPASTLinterRuleTestCase.php',
     'ArcanistDownloadWorkflow' => 'workflow/ArcanistDownloadWorkflow.php',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateKeysInArrayXHPASTLinterRule.php',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase.php',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateSwitchCaseXHPASTLinterRule.php',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase.php',
     'ArcanistDynamicDefineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDynamicDefineXHPASTLinterRule.php',
     'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDynamicDefineXHPASTLinterRuleTestCase.php',
     'ArcanistEachUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEachUseXHPASTLinterRule.php',
     'ArcanistEachUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistEachUseXHPASTLinterRuleTestCase.php',
     'ArcanistElseIfUsageXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistElseIfUsageXHPASTLinterRule.php',
     'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistElseIfUsageXHPASTLinterRuleTestCase.php',
     'ArcanistEmptyFileXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyFileXHPASTLinterRule.php',
     'ArcanistEmptyStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyStatementXHPASTLinterRule.php',
     'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistEmptyStatementXHPASTLinterRuleTestCase.php',
     'ArcanistEventType' => 'events/constant/ArcanistEventType.php',
     'ArcanistExitExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExitExpressionXHPASTLinterRule.php',
     'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExitExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistExportWorkflow' => 'workflow/ArcanistExportWorkflow.php',
     'ArcanistExternalLinter' => 'lint/linter/ArcanistExternalLinter.php',
     'ArcanistExternalLinterTestCase' => 'lint/linter/__tests__/ArcanistExternalLinterTestCase.php',
     'ArcanistExtractUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExtractUseXHPASTLinterRule.php',
     'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExtractUseXHPASTLinterRuleTestCase.php',
     'ArcanistFileConfigurationSource' => 'config/source/ArcanistFileConfigurationSource.php',
     'ArcanistFileDataRef' => 'upload/ArcanistFileDataRef.php',
     'ArcanistFileRef' => 'ref/file/ArcanistFileRef.php',
     'ArcanistFileSymbolRef' => 'ref/file/ArcanistFileSymbolRef.php',
     'ArcanistFileUploader' => 'upload/ArcanistFileUploader.php',
     'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
     'ArcanistFilenameLinterTestCase' => 'lint/linter/__tests__/ArcanistFilenameLinterTestCase.php',
     'ArcanistFilesystemAPI' => 'repository/api/ArcanistFilesystemAPI.php',
     'ArcanistFilesystemConfigurationSource' => 'config/source/ArcanistFilesystemConfigurationSource.php',
     'ArcanistFilesystemWorkingCopy' => 'workingcopy/ArcanistFilesystemWorkingCopy.php',
     'ArcanistFlake8Linter' => 'lint/linter/ArcanistFlake8Linter.php',
     'ArcanistFlake8LinterTestCase' => 'lint/linter/__tests__/ArcanistFlake8LinterTestCase.php',
     'ArcanistFormattedStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFormattedStringXHPASTLinterRule.php',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFormattedStringXHPASTLinterRuleTestCase.php',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule.php',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase.php',
     'ArcanistFutureLinter' => 'lint/linter/ArcanistFutureLinter.php',
     'ArcanistGeneratedLinter' => 'lint/linter/ArcanistGeneratedLinter.php',
     'ArcanistGeneratedLinterTestCase' => 'lint/linter/__tests__/ArcanistGeneratedLinterTestCase.php',
     'ArcanistGetConfigWorkflow' => 'workflow/ArcanistGetConfigWorkflow.php',
     'ArcanistGitAPI' => 'repository/api/ArcanistGitAPI.php',
     'ArcanistGitCommitGraphQuery' => 'repository/graph/query/ArcanistGitCommitGraphQuery.php',
     'ArcanistGitCommitMessageHardpointQuery' => 'query/ArcanistGitCommitMessageHardpointQuery.php',
     'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ref/commit/ArcanistGitCommitSymbolCommitHardpointQuery.php',
     'ArcanistGitLandEngine' => 'land/engine/ArcanistGitLandEngine.php',
     'ArcanistGitLocalState' => 'repository/state/ArcanistGitLocalState.php',
     'ArcanistGitRawCommit' => 'repository/raw/ArcanistGitRawCommit.php',
     'ArcanistGitRawCommitTestCase' => 'repository/raw/__tests__/ArcanistGitRawCommitTestCase.php',
     'ArcanistGitRepositoryMarkerQuery' => 'repository/marker/ArcanistGitRepositoryMarkerQuery.php',
     'ArcanistGitRepositoryRemoteQuery' => 'repository/remote/ArcanistGitRepositoryRemoteQuery.php',
     'ArcanistGitUpstreamPath' => 'repository/api/ArcanistGitUpstreamPath.php',
     'ArcanistGitWorkEngine' => 'work/ArcanistGitWorkEngine.php',
     'ArcanistGitWorkingCopy' => 'workingcopy/ArcanistGitWorkingCopy.php',
     'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'query/ArcanistGitWorkingCopyRevisionHardpointQuery.php',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistGlobalVariableXHPASTLinterRule.php',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistGlobalVariableXHPASTLinterRuleTestCase.php',
     'ArcanistGoLintLinter' => 'lint/linter/ArcanistGoLintLinter.php',
     'ArcanistGoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistGoLintLinterTestCase.php',
     'ArcanistGoTestResultParser' => 'unit/parser/ArcanistGoTestResultParser.php',
     'ArcanistGoTestResultParserTestCase' => 'unit/parser/__tests__/ArcanistGoTestResultParserTestCase.php',
     'ArcanistGridCell' => 'console/grid/ArcanistGridCell.php',
     'ArcanistGridColumn' => 'console/grid/ArcanistGridColumn.php',
     'ArcanistGridRow' => 'console/grid/ArcanistGridRow.php',
     'ArcanistGridView' => 'console/grid/ArcanistGridView.php',
     'ArcanistHLintLinter' => 'lint/linter/ArcanistHLintLinter.php',
     'ArcanistHLintLinterTestCase' => 'lint/linter/__tests__/ArcanistHLintLinterTestCase.php',
     'ArcanistHardpoint' => 'hardpoint/ArcanistHardpoint.php',
     'ArcanistHardpointEngine' => 'hardpoint/ArcanistHardpointEngine.php',
     'ArcanistHardpointFutureList' => 'hardpoint/ArcanistHardpointFutureList.php',
     'ArcanistHardpointList' => 'hardpoint/ArcanistHardpointList.php',
     'ArcanistHardpointObject' => 'hardpoint/ArcanistHardpointObject.php',
     'ArcanistHardpointQuery' => 'hardpoint/ArcanistHardpointQuery.php',
     'ArcanistHardpointRequest' => 'hardpoint/ArcanistHardpointRequest.php',
     'ArcanistHardpointRequestList' => 'hardpoint/ArcanistHardpointRequestList.php',
     'ArcanistHardpointTask' => 'hardpoint/ArcanistHardpointTask.php',
     'ArcanistHardpointTaskResult' => 'hardpoint/ArcanistHardpointTaskResult.php',
     'ArcanistHelpWorkflow' => 'toolset/workflow/ArcanistHelpWorkflow.php',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule.php',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase.php',
     'ArcanistHgClientChannel' => 'hgdaemon/ArcanistHgClientChannel.php',
     'ArcanistHgProxyClient' => 'hgdaemon/ArcanistHgProxyClient.php',
     'ArcanistHgProxyServer' => 'hgdaemon/ArcanistHgProxyServer.php',
     'ArcanistHgServerChannel' => 'hgdaemon/ArcanistHgServerChannel.php',
     'ArcanistHostMemorySnapshot' => 'filesystem/memory/ArcanistHostMemorySnapshot.php',
     'ArcanistHostMemorySnapshotTestCase' => 'filesystem/memory/__tests__/ArcanistHostMemorySnapshotTestCase.php',
     'ArcanistImplicitConstructorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitConstructorXHPASTLinterRule.php',
     'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitConstructorXHPASTLinterRuleTestCase.php',
     'ArcanistImplicitFallthroughXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitFallthroughXHPASTLinterRule.php',
     'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitFallthroughXHPASTLinterRuleTestCase.php',
     'ArcanistImplicitVisibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitVisibilityXHPASTLinterRule.php',
     'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitVisibilityXHPASTLinterRuleTestCase.php',
     'ArcanistImplodeArgumentOrderXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplodeArgumentOrderXHPASTLinterRule.php',
     'ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase.php',
     'ArcanistInlineHTMLXHPASTLinterRule' => 'lint/linter/ArcanistInlineHTMLXHPASTLinterRule.php',
     'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInlineHTMLXHPASTLinterRuleTestCase.php',
     'ArcanistInnerFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInnerFunctionXHPASTLinterRule.php',
     'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInnerFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistInspectWorkflow' => 'workflow/ArcanistInspectWorkflow.php',
     'ArcanistInstallCertificateWorkflow' => 'workflow/ArcanistInstallCertificateWorkflow.php',
     'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInstanceOfOperatorXHPASTLinterRule.php',
     'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInstanceofOperatorXHPASTLinterRuleTestCase.php',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceAbstractMethodXHPASTLinterRule.php',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase.php',
     'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceMethodBodyXHPASTLinterRule.php',
     'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidDefaultParameterXHPASTLinterRule.php',
     'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidModifiersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidModifiersXHPASTLinterRule.php',
     'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidModifiersXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidOctalNumericScalarXHPASTLinterRule.php',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase.php',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistIsAShouldBeInstanceOfXHPASTLinterRule.php',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase.php',
     'ArcanistJSHintLinter' => 'lint/linter/ArcanistJSHintLinter.php',
     'ArcanistJSHintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSHintLinterTestCase.php',
     'ArcanistJSONLintLinter' => 'lint/linter/ArcanistJSONLintLinter.php',
     'ArcanistJSONLintRenderer' => 'lint/renderer/ArcanistJSONLintRenderer.php',
     'ArcanistJSONLinter' => 'lint/linter/ArcanistJSONLinter.php',
     'ArcanistJSONLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLinterTestCase.php',
     'ArcanistJscsLinter' => 'lint/linter/ArcanistJscsLinter.php',
     'ArcanistJscsLinterTestCase' => 'lint/linter/__tests__/ArcanistJscsLinterTestCase.php',
     'ArcanistKeywordCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistKeywordCasingXHPASTLinterRule.php',
     'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistKeywordCasingXHPASTLinterRuleTestCase.php',
     'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLambdaFuncFunctionXHPASTLinterRule.php',
     'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistLandCommit' => 'land/ArcanistLandCommit.php',
     'ArcanistLandCommitSet' => 'land/ArcanistLandCommitSet.php',
     'ArcanistLandEngine' => 'land/engine/ArcanistLandEngine.php',
     'ArcanistLandPushFailureException' => 'land/exception/ArcanistLandPushFailureException.php',
     'ArcanistLandSymbol' => 'land/ArcanistLandSymbol.php',
     'ArcanistLandTarget' => 'land/ArcanistLandTarget.php',
     'ArcanistLandWorkflow' => 'workflow/ArcanistLandWorkflow.php',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLanguageConstructParenthesesXHPASTLinterRule.php',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistLesscLinter' => 'lint/linter/ArcanistLesscLinter.php',
     'ArcanistLesscLinterTestCase' => 'lint/linter/__tests__/ArcanistLesscLinterTestCase.php',
     'ArcanistLiberateWorkflow' => 'workflow/ArcanistLiberateWorkflow.php',
     'ArcanistLintEngine' => 'lint/engine/ArcanistLintEngine.php',
     'ArcanistLintMessage' => 'lint/ArcanistLintMessage.php',
     'ArcanistLintMessageTestCase' => 'lint/__tests__/ArcanistLintMessageTestCase.php',
     'ArcanistLintPatcher' => 'lint/ArcanistLintPatcher.php',
     'ArcanistLintRenderer' => 'lint/renderer/ArcanistLintRenderer.php',
     'ArcanistLintResult' => 'lint/ArcanistLintResult.php',
     'ArcanistLintSeverity' => 'lint/ArcanistLintSeverity.php',
     'ArcanistLintWorkflow' => 'workflow/ArcanistLintWorkflow.php',
     'ArcanistLinter' => 'lint/linter/ArcanistLinter.php',
     'ArcanistLinterStandard' => 'lint/linter/standards/ArcanistLinterStandard.php',
     'ArcanistLinterStandardTestCase' => 'lint/linter/standards/__tests__/ArcanistLinterStandardTestCase.php',
     'ArcanistLinterTestCase' => 'lint/linter/__tests__/ArcanistLinterTestCase.php',
     'ArcanistLintersWorkflow' => 'workflow/ArcanistLintersWorkflow.php',
     'ArcanistListAssignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistListAssignmentXHPASTLinterRule.php',
     'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistListAssignmentXHPASTLinterRuleTestCase.php',
     'ArcanistListConfigOption' => 'config/option/ArcanistListConfigOption.php',
     'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
     'ArcanistLocalConfigurationSource' => 'config/source/ArcanistLocalConfigurationSource.php',
     'ArcanistLogEngine' => 'log/ArcanistLogEngine.php',
     'ArcanistLogMessage' => 'log/ArcanistLogMessage.php',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLogicalOperatorsXHPASTLinterRule.php',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLogicalOperatorsXHPASTLinterRuleTestCase.php',
     'ArcanistLookWorkflow' => 'workflow/ArcanistLookWorkflow.php',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLowercaseFunctionsXHPASTLinterRule.php',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase.php',
     'ArcanistMarkerRef' => 'repository/marker/ArcanistMarkerRef.php',
     'ArcanistMarkersWorkflow' => 'workflow/ArcanistMarkersWorkflow.php',
     'ArcanistMercurialAPI' => 'repository/api/ArcanistMercurialAPI.php',
     'ArcanistMercurialCommitGraphQuery' => 'repository/graph/query/ArcanistMercurialCommitGraphQuery.php',
     'ArcanistMercurialCommitMessageHardpointQuery' => 'query/ArcanistMercurialCommitMessageHardpointQuery.php',
     'ArcanistMercurialCommitSymbolCommitHardpointQuery' => 'ref/commit/ArcanistMercurialCommitSymbolCommitHardpointQuery.php',
     'ArcanistMercurialLandEngine' => 'land/engine/ArcanistMercurialLandEngine.php',
     'ArcanistMercurialLocalState' => 'repository/state/ArcanistMercurialLocalState.php',
     'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
     'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
     'ArcanistMercurialRepositoryMarkerQuery' => 'repository/marker/ArcanistMercurialRepositoryMarkerQuery.php',
     'ArcanistMercurialRepositoryRemoteQuery' => 'repository/remote/ArcanistMercurialRepositoryRemoteQuery.php',
     'ArcanistMercurialWorkEngine' => 'work/ArcanistMercurialWorkEngine.php',
     'ArcanistMercurialWorkingCopy' => 'workingcopy/ArcanistMercurialWorkingCopy.php',
     'ArcanistMercurialWorkingCopyRevisionHardpointQuery' => 'query/ArcanistMercurialWorkingCopyRevisionHardpointQuery.php',
     'ArcanistMergeConflictLinter' => 'lint/linter/ArcanistMergeConflictLinter.php',
     'ArcanistMergeConflictLinterTestCase' => 'lint/linter/__tests__/ArcanistMergeConflictLinterTestCase.php',
     'ArcanistMessageRevisionHardpointQuery' => 'query/ArcanistMessageRevisionHardpointQuery.php',
     'ArcanistMissingArgumentTerminatorException' => 'exception/ArcanistMissingArgumentTerminatorException.php',
     'ArcanistMissingLinterException' => 'lint/linter/exception/ArcanistMissingLinterException.php',
     'ArcanistModifierOrderingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistModifierOrderingXHPASTLinterRule.php',
     'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistModifierOrderingXHPASTLinterRuleTestCase.php',
     'ArcanistMultiSourceConfigOption' => 'config/option/ArcanistMultiSourceConfigOption.php',
     'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamespaceFirstStatementXHPASTLinterRule.php',
     'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase.php',
     'ArcanistNamingConventionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamingConventionsXHPASTLinterRule.php',
     'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamingConventionsXHPASTLinterRuleTestCase.php',
     'ArcanistNestedNamespacesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNestedNamespacesXHPASTLinterRule.php',
     'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNestedNamespacesXHPASTLinterRuleTestCase.php',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNewlineAfterOpenTagXHPASTLinterRule.php',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase.php',
     'ArcanistNoEffectException' => 'exception/usage/ArcanistNoEffectException.php',
     'ArcanistNoEngineException' => 'exception/usage/ArcanistNoEngineException.php',
     'ArcanistNoLintLinter' => 'lint/linter/ArcanistNoLintLinter.php',
     'ArcanistNoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistNoLintLinterTestCase.php',
     'ArcanistNoParentScopeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNoParentScopeXHPASTLinterRule.php',
     'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNoParentScopeXHPASTLinterRuleTestCase.php',
     'ArcanistNoURIConduitException' => 'conduit/ArcanistNoURIConduitException.php',
     'ArcanistNonblockingGuard' => 'utils/ArcanistNonblockingGuard.php',
     'ArcanistNoneLintRenderer' => 'lint/renderer/ArcanistNoneLintRenderer.php',
     'ArcanistObjectListHardpoint' => 'hardpoint/ArcanistObjectListHardpoint.php',
     'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistObjectOperatorSpacingXHPASTLinterRule.php',
     'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistPEP8Linter' => 'lint/linter/ArcanistPEP8Linter.php',
     'ArcanistPEP8LinterTestCase' => 'lint/linter/__tests__/ArcanistPEP8LinterTestCase.php',
     'ArcanistPHPCloseTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCloseTagXHPASTLinterRule.php',
     'ArcanistPHPCloseTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPCloseTagXHPASTLinterRuleTestCase.php',
     'ArcanistPHPCompatibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCompatibilityXHPASTLinterRule.php',
     'ArcanistPHPCompatibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPCompatibilityXHPASTLinterRuleTestCase.php',
     'ArcanistPHPEchoTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPEchoTagXHPASTLinterRule.php',
     'ArcanistPHPEchoTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPEchoTagXHPASTLinterRuleTestCase.php',
     'ArcanistPHPOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPOpenTagXHPASTLinterRule.php',
     'ArcanistPHPOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPOpenTagXHPASTLinterRuleTestCase.php',
     'ArcanistPHPShortTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPShortTagXHPASTLinterRule.php',
     'ArcanistPHPShortTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPShortTagXHPASTLinterRuleTestCase.php',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule.php',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistParentMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParentMemberReferenceXHPASTLinterRule.php',
     'ArcanistParentMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParentMemberReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistParenthesesSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParenthesesSpacingXHPASTLinterRule.php',
     'ArcanistParenthesesSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParenthesesSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistParseStrUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParseStrUseXHPASTLinterRule.php',
     'ArcanistParseStrUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParseStrUseXHPASTLinterRuleTestCase.php',
     'ArcanistPartialCatchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPartialCatchXHPASTLinterRule.php',
     'ArcanistPartialCatchXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPartialCatchXHPASTLinterRuleTestCase.php',
     'ArcanistPasteRef' => 'ref/paste/ArcanistPasteRef.php',
     'ArcanistPasteSymbolRef' => 'ref/paste/ArcanistPasteSymbolRef.php',
     'ArcanistPasteWorkflow' => 'workflow/ArcanistPasteWorkflow.php',
     'ArcanistPatchWorkflow' => 'workflow/ArcanistPatchWorkflow.php',
     'ArcanistPhpLinter' => 'lint/linter/ArcanistPhpLinter.php',
     'ArcanistPhpLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpLinterTestCase.php',
     'ArcanistPhpcsLinter' => 'lint/linter/ArcanistPhpcsLinter.php',
     'ArcanistPhpcsLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpcsLinterTestCase.php',
     'ArcanistPhpunitTestResultParser' => 'unit/parser/ArcanistPhpunitTestResultParser.php',
     'ArcanistPhutilLibraryLinter' => 'lint/linter/ArcanistPhutilLibraryLinter.php',
     'ArcanistPhutilWorkflow' => 'toolset/ArcanistPhutilWorkflow.php',
     'ArcanistPhutilXHPASTLinterStandard' => 'lint/linter/standards/phutil/ArcanistPhutilXHPASTLinterStandard.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPlusOperatorOnStringsXHPASTLinterRule.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase.php',
+    'ArcanistProductNameLiteralXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistProductNameLiteralXHPASTLinterRule.php',
     'ArcanistProjectConfigurationSource' => 'config/source/ArcanistProjectConfigurationSource.php',
     'ArcanistPrompt' => 'toolset/ArcanistPrompt.php',
     'ArcanistPromptResponse' => 'toolset/ArcanistPromptResponse.php',
     'ArcanistPromptsConfigOption' => 'config/option/ArcanistPromptsConfigOption.php',
     'ArcanistPromptsWorkflow' => 'toolset/workflow/ArcanistPromptsWorkflow.php',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPublicPropertyXHPASTLinterRule.php',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPublicPropertyXHPASTLinterRuleTestCase.php',
     'ArcanistPuppetLintLinter' => 'lint/linter/ArcanistPuppetLintLinter.php',
     'ArcanistPuppetLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPuppetLintLinterTestCase.php',
     'ArcanistPyFlakesLinter' => 'lint/linter/ArcanistPyFlakesLinter.php',
     'ArcanistPyFlakesLinterTestCase' => 'lint/linter/__tests__/ArcanistPyFlakesLinterTestCase.php',
     'ArcanistPyLintLinter' => 'lint/linter/ArcanistPyLintLinter.php',
     'ArcanistPyLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPyLintLinterTestCase.php',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistRaggedClassTreeEdgeXHPASTLinterRule.php',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase.php',
     'ArcanistRef' => 'ref/ArcanistRef.php',
     'ArcanistRefInspector' => 'inspector/ArcanistRefInspector.php',
     'ArcanistRefView' => 'ref/ArcanistRefView.php',
     'ArcanistRemoteRef' => 'repository/remote/ArcanistRemoteRef.php',
     'ArcanistRemoteRefInspector' => 'repository/remote/ArcanistRemoteRefInspector.php',
     'ArcanistRemoteRepositoryRefsHardpointQuery' => 'repository/remote/ArcanistRemoteRepositoryRefsHardpointQuery.php',
     'ArcanistRepositoryAPI' => 'repository/api/ArcanistRepositoryAPI.php',
     'ArcanistRepositoryAPIMiscTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIMiscTestCase.php',
     'ArcanistRepositoryAPIStateTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php',
     'ArcanistRepositoryLocalState' => 'repository/state/ArcanistRepositoryLocalState.php',
     'ArcanistRepositoryMarkerQuery' => 'repository/marker/ArcanistRepositoryMarkerQuery.php',
     'ArcanistRepositoryQuery' => 'repository/query/ArcanistRepositoryQuery.php',
     'ArcanistRepositoryRef' => 'ref/ArcanistRepositoryRef.php',
     'ArcanistRepositoryRemoteQuery' => 'repository/remote/ArcanistRepositoryRemoteQuery.php',
     'ArcanistRepositoryURINormalizer' => 'repository/remote/ArcanistRepositoryURINormalizer.php',
     'ArcanistRepositoryURINormalizerTestCase' => 'repository/remote/__tests__/ArcanistRepositoryURINormalizerTestCase.php',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedAsIteratorXHPASTLinterRule.php',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedAsIteratorXHPASTLinterRuleTestCase.php',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorReferenceXHPASTLinterRule.php',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorXHPASTLinterRule.php',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorXHPASTLinterRuleTestCase.php',
     'ArcanistRevisionAuthorHardpointQuery' => 'ref/revision/ArcanistRevisionAuthorHardpointQuery.php',
     'ArcanistRevisionBuildableHardpointQuery' => 'ref/revision/ArcanistRevisionBuildableHardpointQuery.php',
     'ArcanistRevisionCommitMessageHardpointQuery' => 'ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php',
     'ArcanistRevisionParentRevisionsHardpointQuery' => 'ref/revision/ArcanistRevisionParentRevisionsHardpointQuery.php',
     'ArcanistRevisionRef' => 'ref/revision/ArcanistRevisionRef.php',
     'ArcanistRevisionRefSource' => 'ref/ArcanistRevisionRefSource.php',
     'ArcanistRevisionSymbolRef' => 'ref/revision/ArcanistRevisionSymbolRef.php',
     'ArcanistRuboCopLinter' => 'lint/linter/ArcanistRuboCopLinter.php',
     'ArcanistRuboCopLinterTestCase' => 'lint/linter/__tests__/ArcanistRuboCopLinterTestCase.php',
     'ArcanistRubyLinter' => 'lint/linter/ArcanistRubyLinter.php',
     'ArcanistRubyLinterTestCase' => 'lint/linter/__tests__/ArcanistRubyLinterTestCase.php',
     'ArcanistRuntime' => 'runtime/ArcanistRuntime.php',
     'ArcanistRuntimeConfigurationSource' => 'config/source/ArcanistRuntimeConfigurationSource.php',
     'ArcanistRuntimeHardpointQuery' => 'toolset/query/ArcanistRuntimeHardpointQuery.php',
     'ArcanistScalarHardpoint' => 'hardpoint/ArcanistScalarHardpoint.php',
     'ArcanistScriptAndRegexLinter' => 'lint/linter/ArcanistScriptAndRegexLinter.php',
     'ArcanistSelfClassReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfClassReferenceXHPASTLinterRule.php',
     'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfClassReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfMemberReferenceXHPASTLinterRule.php',
     'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistSemicolonSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSemicolonSpacingXHPASTLinterRule.php',
     'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSemicolonSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistSetConfigWorkflow' => 'workflow/ArcanistSetConfigWorkflow.php',
     'ArcanistSetting' => 'configuration/ArcanistSetting.php',
     'ArcanistSettings' => 'configuration/ArcanistSettings.php',
     'ArcanistShellCompleteWorkflow' => 'toolset/workflow/ArcanistShellCompleteWorkflow.php',
     'ArcanistSimpleCommitGraphQuery' => 'repository/graph/query/ArcanistSimpleCommitGraphQuery.php',
     'ArcanistSimpleSymbolHardpointQuery' => 'ref/simple/ArcanistSimpleSymbolHardpointQuery.php',
     'ArcanistSimpleSymbolRef' => 'ref/simple/ArcanistSimpleSymbolRef.php',
     'ArcanistSimpleSymbolRefInspector' => 'ref/simple/ArcanistSimpleSymbolRefInspector.php',
     'ArcanistSingleLintEngine' => 'lint/engine/ArcanistSingleLintEngine.php',
     'ArcanistSingleSourceConfigOption' => 'config/option/ArcanistSingleSourceConfigOption.php',
     'ArcanistSlownessXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSlownessXHPASTLinterRule.php',
     'ArcanistSlownessXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSlownessXHPASTLinterRuleTestCase.php',
     'ArcanistSpellingLinter' => 'lint/linter/ArcanistSpellingLinter.php',
     'ArcanistSpellingLinterTestCase' => 'lint/linter/__tests__/ArcanistSpellingLinterTestCase.php',
     'ArcanistStaticThisXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistStaticThisXHPASTLinterRule.php',
     'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistStaticThisXHPASTLinterRuleTestCase.php',
     'ArcanistStringConfigOption' => 'config/option/ArcanistStringConfigOption.php',
     'ArcanistStringListConfigOption' => 'config/option/ArcanistStringListConfigOption.php',
     'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
     'ArcanistSubversionWorkingCopy' => 'workingcopy/ArcanistSubversionWorkingCopy.php',
     'ArcanistSummaryLintRenderer' => 'lint/renderer/ArcanistSummaryLintRenderer.php',
     'ArcanistSymbolEngine' => 'ref/symbol/ArcanistSymbolEngine.php',
     'ArcanistSymbolRef' => 'ref/symbol/ArcanistSymbolRef.php',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSyntaxErrorXHPASTLinterRule.php',
     'ArcanistSystemConfigurationSource' => 'config/source/ArcanistSystemConfigurationSource.php',
     'ArcanistTaskRef' => 'ref/task/ArcanistTaskRef.php',
     'ArcanistTaskSymbolRef' => 'ref/task/ArcanistTaskSymbolRef.php',
     'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTautologicalExpressionXHPASTLinterRule.php',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTautologicalExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistTerminalStringInterface' => 'xsprintf/ArcanistTerminalStringInterface.php',
     'ArcanistTestResultParser' => 'unit/parser/ArcanistTestResultParser.php',
     'ArcanistTestXHPASTLintSwitchHook' => 'lint/linter/__tests__/ArcanistTestXHPASTLintSwitchHook.php',
     'ArcanistTextLinter' => 'lint/linter/ArcanistTextLinter.php',
     'ArcanistTextLinterTestCase' => 'lint/linter/__tests__/ArcanistTextLinterTestCase.php',
     'ArcanistThisReassignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistThisReassignmentXHPASTLinterRule.php',
     'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistThisReassignmentXHPASTLinterRuleTestCase.php',
     'ArcanistToStringExceptionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistToStringExceptionXHPASTLinterRule.php',
     'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistToStringExceptionXHPASTLinterRuleTestCase.php',
     'ArcanistTodoCommentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTodoCommentXHPASTLinterRule.php',
     'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTodoCommentXHPASTLinterRuleTestCase.php',
     'ArcanistTodoWorkflow' => 'workflow/ArcanistTodoWorkflow.php',
     'ArcanistToolset' => 'toolset/ArcanistToolset.php',
     'ArcanistUSEnglishTranslation' => 'internationalization/ArcanistUSEnglishTranslation.php',
     'ArcanistUnableToParseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnableToParseXHPASTLinterRule.php',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule.php',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule.php',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistUndeclaredVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUndeclaredVariableXHPASTLinterRule.php',
     'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUndeclaredVariableXHPASTLinterRuleTestCase.php',
     'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnexpectedReturnValueXHPASTLinterRule.php',
     'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase.php',
     'ArcanistUnitConsoleRenderer' => 'unit/renderer/ArcanistUnitConsoleRenderer.php',
     'ArcanistUnitRenderer' => 'unit/renderer/ArcanistUnitRenderer.php',
     'ArcanistUnitTestEngine' => 'unit/engine/ArcanistUnitTestEngine.php',
     'ArcanistUnitTestResult' => 'unit/ArcanistUnitTestResult.php',
     'ArcanistUnitTestResultTestCase' => 'unit/__tests__/ArcanistUnitTestResultTestCase.php',
     'ArcanistUnitTestableLintEngine' => 'lint/engine/ArcanistUnitTestableLintEngine.php',
     'ArcanistUnitWorkflow' => 'workflow/ArcanistUnitWorkflow.php',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessaryFinalModifierXHPASTLinterRule.php',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase.php',
     'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySemicolonXHPASTLinterRule.php',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySymbolAliasXHPASTLinterRule.php',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase.php',
     'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnsafeDynamicStringXHPASTLinterRule.php',
     'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase.php',
     'ArcanistUpgradeWorkflow' => 'workflow/ArcanistUpgradeWorkflow.php',
     'ArcanistUploadWorkflow' => 'workflow/ArcanistUploadWorkflow.php',
     'ArcanistUsageException' => 'exception/ArcanistUsageException.php',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUseStatementNamespacePrefixXHPASTLinterRule.php',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase.php',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUselessOverridingMethodXHPASTLinterRule.php',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase.php',
     'ArcanistUserAbortException' => 'exception/usage/ArcanistUserAbortException.php',
     'ArcanistUserConfigurationSource' => 'config/source/ArcanistUserConfigurationSource.php',
     'ArcanistUserRef' => 'ref/user/ArcanistUserRef.php',
     'ArcanistUserSymbolHardpointQuery' => 'ref/user/ArcanistUserSymbolHardpointQuery.php',
     'ArcanistUserSymbolRef' => 'ref/user/ArcanistUserSymbolRef.php',
     'ArcanistUserSymbolRefInspector' => 'ref/user/ArcanistUserSymbolRefInspector.php',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableReferenceSpacingXHPASTLinterRule.php',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistVariableVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableVariableXHPASTLinterRule.php',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableVariableXHPASTLinterRuleTestCase.php',
     'ArcanistVectorHardpoint' => 'hardpoint/ArcanistVectorHardpoint.php',
     'ArcanistVersionWorkflow' => 'toolset/workflow/ArcanistVersionWorkflow.php',
     'ArcanistWeldWorkflow' => 'workflow/ArcanistWeldWorkflow.php',
     'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
     'ArcanistWildConfigOption' => 'config/option/ArcanistWildConfigOption.php',
     'ArcanistWorkEngine' => 'work/ArcanistWorkEngine.php',
     'ArcanistWorkWorkflow' => 'workflow/ArcanistWorkWorkflow.php',
     'ArcanistWorkflow' => 'workflow/ArcanistWorkflow.php',
     'ArcanistWorkflowArgument' => 'toolset/ArcanistWorkflowArgument.php',
     'ArcanistWorkflowEngine' => 'engine/ArcanistWorkflowEngine.php',
     'ArcanistWorkflowGitHardpointQuery' => 'query/ArcanistWorkflowGitHardpointQuery.php',
     'ArcanistWorkflowInformation' => 'toolset/ArcanistWorkflowInformation.php',
     'ArcanistWorkflowMercurialHardpointQuery' => 'query/ArcanistWorkflowMercurialHardpointQuery.php',
     'ArcanistWorkingCopy' => 'workingcopy/ArcanistWorkingCopy.php',
     'ArcanistWorkingCopyConfigurationSource' => 'config/source/ArcanistWorkingCopyConfigurationSource.php',
     'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.php',
     'ArcanistWorkingCopyPath' => 'workingcopy/ArcanistWorkingCopyPath.php',
     'ArcanistWorkingCopyStateRef' => 'ref/ArcanistWorkingCopyStateRef.php',
     'ArcanistWorkingCopyStateRefInspector' => 'inspector/ArcanistWorkingCopyStateRefInspector.php',
     'ArcanistXHPASTLintNamingHook' => 'lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php',
     'ArcanistXHPASTLintNamingHookTestCase' => 'lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php',
     'ArcanistXHPASTLintSwitchHook' => 'lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php',
     'ArcanistXHPASTLinter' => 'lint/linter/ArcanistXHPASTLinter.php',
     'ArcanistXHPASTLinterRule' => 'lint/linter/xhpast/ArcanistXHPASTLinterRule.php',
     'ArcanistXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php',
     'ArcanistXHPASTLinterTestCase' => 'lint/linter/__tests__/ArcanistXHPASTLinterTestCase.php',
     'ArcanistXMLLinter' => 'lint/linter/ArcanistXMLLinter.php',
     'ArcanistXMLLinterTestCase' => 'lint/linter/__tests__/ArcanistXMLLinterTestCase.php',
     'ArcanistXUnitTestResultParser' => 'unit/parser/ArcanistXUnitTestResultParser.php',
     'BaseHTTPFuture' => 'future/http/BaseHTTPFuture.php',
     'CSharpToolsTestEngine' => 'unit/engine/CSharpToolsTestEngine.php',
     'CaseInsensitiveArray' => 'utils/CaseInsensitiveArray.php',
     'CaseInsensitiveArrayTestCase' => 'utils/__tests__/CaseInsensitiveArrayTestCase.php',
     'CommandException' => 'future/exec/CommandException.php',
     'ConduitClient' => 'conduit/ConduitClient.php',
     'ConduitClientException' => 'conduit/ConduitClientException.php',
     'ConduitClientTestCase' => 'conduit/__tests__/ConduitClientTestCase.php',
     'ConduitFuture' => 'conduit/ConduitFuture.php',
     'ConduitSearchFuture' => 'conduit/ConduitSearchFuture.php',
     'ExecFuture' => 'future/exec/ExecFuture.php',
     'ExecFutureTestCase' => 'future/exec/__tests__/ExecFutureTestCase.php',
     'ExecPassthruTestCase' => 'future/exec/__tests__/ExecPassthruTestCase.php',
     'FileFinder' => 'filesystem/FileFinder.php',
     'FileFinderTestCase' => 'filesystem/__tests__/FileFinderTestCase.php',
     'FileList' => 'filesystem/FileList.php',
     'Filesystem' => 'filesystem/Filesystem.php',
     'FilesystemException' => 'filesystem/FilesystemException.php',
     'FilesystemTestCase' => 'filesystem/__tests__/FilesystemTestCase.php',
     'Future' => 'future/Future.php',
     'FutureAgent' => 'conduit/FutureAgent.php',
     'FutureIterator' => 'future/FutureIterator.php',
     'FutureIteratorTestCase' => 'future/__tests__/FutureIteratorTestCase.php',
     'FuturePool' => 'future/FuturePool.php',
     'FutureProxy' => 'future/FutureProxy.php',
     'HTTPFuture' => 'future/http/HTTPFuture.php',
     'HTTPFutureCURLResponseStatus' => 'future/http/status/HTTPFutureCURLResponseStatus.php',
     'HTTPFutureCertificateResponseStatus' => 'future/http/status/HTTPFutureCertificateResponseStatus.php',
     'HTTPFutureHTTPResponseStatus' => 'future/http/status/HTTPFutureHTTPResponseStatus.php',
     'HTTPFutureParseResponseStatus' => 'future/http/status/HTTPFutureParseResponseStatus.php',
     'HTTPFutureResponseStatus' => 'future/http/status/HTTPFutureResponseStatus.php',
     'HTTPFutureTransportResponseStatus' => 'future/http/status/HTTPFutureTransportResponseStatus.php',
     'HTTPSFuture' => 'future/http/HTTPSFuture.php',
     'ImmediateFuture' => 'future/ImmediateFuture.php',
     'LibphutilUSEnglishTranslation' => 'internationalization/translation/LibphutilUSEnglishTranslation.php',
     'LinesOfALarge' => 'filesystem/linesofalarge/LinesOfALarge.php',
     'LinesOfALargeExecFuture' => 'filesystem/linesofalarge/LinesOfALargeExecFuture.php',
     'LinesOfALargeExecFutureTestCase' => 'filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php',
     'LinesOfALargeFile' => 'filesystem/linesofalarge/LinesOfALargeFile.php',
     'LinesOfALargeFileTestCase' => 'filesystem/linesofalarge/__tests__/LinesOfALargeFileTestCase.php',
     'MFilterTestHelper' => 'utils/__tests__/MFilterTestHelper.php',
     'MethodCallFuture' => 'future/MethodCallFuture.php',
     'MethodCallFutureTestCase' => 'future/__tests__/MethodCallFutureTestCase.php',
     'NoseTestEngine' => 'unit/engine/NoseTestEngine.php',
     'PHPASTParserTestCase' => 'parser/xhpast/__tests__/PHPASTParserTestCase.php',
     'PhageAction' => 'phage/action/PhageAction.php',
     'PhageAgentAction' => 'phage/action/PhageAgentAction.php',
     'PhageAgentBootloader' => 'phage/bootloader/PhageAgentBootloader.php',
     'PhageAgentTestCase' => 'phage/__tests__/PhageAgentTestCase.php',
     'PhageExecWorkflow' => 'phage/workflow/PhageExecWorkflow.php',
     'PhageExecuteAction' => 'phage/action/PhageExecuteAction.php',
     'PhageLocalAction' => 'phage/action/PhageLocalAction.php',
     'PhagePHPAgent' => 'phage/agent/PhagePHPAgent.php',
     'PhagePHPAgentBootloader' => 'phage/bootloader/PhagePHPAgentBootloader.php',
     'PhagePlanAction' => 'phage/action/PhagePlanAction.php',
     'PhageToolset' => 'phage/toolset/PhageToolset.php',
     'PhageWorkflow' => 'phage/workflow/PhageWorkflow.php',
     'Phobject' => 'object/Phobject.php',
     'PhobjectTestCase' => 'object/__tests__/PhobjectTestCase.php',
     'PhpunitTestEngine' => 'unit/engine/PhpunitTestEngine.php',
     'PhpunitTestEngineTestCase' => 'unit/engine/__tests__/PhpunitTestEngineTestCase.php',
     'PhutilAWSCloudFormationFuture' => 'future/aws/PhutilAWSCloudFormationFuture.php',
     'PhutilAWSCloudWatchFuture' => 'future/aws/PhutilAWSCloudWatchFuture.php',
     'PhutilAWSEC2Future' => 'future/aws/PhutilAWSEC2Future.php',
     'PhutilAWSException' => 'future/aws/PhutilAWSException.php',
     'PhutilAWSFuture' => 'future/aws/PhutilAWSFuture.php',
     'PhutilAWSManagementWorkflow' => 'future/aws/management/PhutilAWSManagementWorkflow.php',
     'PhutilAWSS3DeleteManagementWorkflow' => 'future/aws/management/PhutilAWSS3DeleteManagementWorkflow.php',
     'PhutilAWSS3Future' => 'future/aws/PhutilAWSS3Future.php',
     'PhutilAWSS3GetManagementWorkflow' => 'future/aws/management/PhutilAWSS3GetManagementWorkflow.php',
     'PhutilAWSS3ManagementWorkflow' => 'future/aws/management/PhutilAWSS3ManagementWorkflow.php',
     'PhutilAWSS3PutManagementWorkflow' => 'future/aws/management/PhutilAWSS3PutManagementWorkflow.php',
     'PhutilAWSv4Signature' => 'future/aws/PhutilAWSv4Signature.php',
     'PhutilAWSv4SignatureTestCase' => 'future/aws/__tests__/PhutilAWSv4SignatureTestCase.php',
     'PhutilAggregateException' => 'error/PhutilAggregateException.php',
     'PhutilAllCapsEnglishLocale' => 'internationalization/locales/PhutilAllCapsEnglishLocale.php',
     'PhutilArgumentParser' => 'parser/argument/PhutilArgumentParser.php',
     'PhutilArgumentParserException' => 'parser/argument/exception/PhutilArgumentParserException.php',
     'PhutilArgumentParserTestCase' => 'parser/argument/__tests__/PhutilArgumentParserTestCase.php',
     'PhutilArgumentSpecification' => 'parser/argument/PhutilArgumentSpecification.php',
     'PhutilArgumentSpecificationException' => 'parser/argument/exception/PhutilArgumentSpecificationException.php',
     'PhutilArgumentSpecificationTestCase' => 'parser/argument/__tests__/PhutilArgumentSpecificationTestCase.php',
     'PhutilArgumentSpellingCorrector' => 'parser/argument/PhutilArgumentSpellingCorrector.php',
     'PhutilArgumentSpellingCorrectorTestCase' => 'parser/argument/__tests__/PhutilArgumentSpellingCorrectorTestCase.php',
     'PhutilArgumentUsageException' => 'parser/argument/exception/PhutilArgumentUsageException.php',
     'PhutilArgumentWorkflow' => 'parser/argument/workflow/PhutilArgumentWorkflow.php',
     'PhutilArray' => 'utils/PhutilArray.php',
     'PhutilArrayCheck' => 'utils/PhutilArrayCheck.php',
     'PhutilArrayTestCase' => 'utils/__tests__/PhutilArrayTestCase.php',
     'PhutilArrayWithDefaultValue' => 'utils/PhutilArrayWithDefaultValue.php',
     'PhutilAsanaFuture' => 'future/asana/PhutilAsanaFuture.php',
     'PhutilBacktraceSignalHandler' => 'future/exec/PhutilBacktraceSignalHandler.php',
     'PhutilBallOfPHP' => 'phage/util/PhutilBallOfPHP.php',
     'PhutilBinaryAnalyzer' => 'filesystem/binary/PhutilBinaryAnalyzer.php',
     'PhutilBinaryAnalyzerTestCase' => 'filesystem/binary/__tests__/PhutilBinaryAnalyzerTestCase.php',
     'PhutilBootloader' => 'init/lib/PhutilBootloader.php',
     'PhutilBootloaderException' => 'init/lib/PhutilBootloaderException.php',
     'PhutilBritishEnglishLocale' => 'internationalization/locales/PhutilBritishEnglishLocale.php',
     'PhutilBufferedIterator' => 'utils/PhutilBufferedIterator.php',
     'PhutilBufferedIteratorTestCase' => 'utils/__tests__/PhutilBufferedIteratorTestCase.php',
     'PhutilBugtraqParser' => 'parser/PhutilBugtraqParser.php',
     'PhutilBugtraqParserTestCase' => 'parser/__tests__/PhutilBugtraqParserTestCase.php',
     'PhutilCIDRBlock' => 'ip/PhutilCIDRBlock.php',
     'PhutilCIDRList' => 'ip/PhutilCIDRList.php',
     'PhutilCallbackFilterIterator' => 'utils/PhutilCallbackFilterIterator.php',
     'PhutilCallbackSignalHandler' => 'future/exec/PhutilCallbackSignalHandler.php',
     'PhutilChannel' => 'channel/PhutilChannel.php',
     'PhutilChannelChannel' => 'channel/PhutilChannelChannel.php',
     'PhutilChannelTestCase' => 'channel/__tests__/PhutilChannelTestCase.php',
     'PhutilChunkedIterator' => 'utils/PhutilChunkedIterator.php',
     'PhutilChunkedIteratorTestCase' => 'utils/__tests__/PhutilChunkedIteratorTestCase.php',
     'PhutilClassMapQuery' => 'symbols/PhutilClassMapQuery.php',
     'PhutilCloudWatchMetric' => 'future/aws/PhutilCloudWatchMetric.php',
     'PhutilCommandString' => 'xsprintf/PhutilCommandString.php',
     'PhutilConsole' => 'console/PhutilConsole.php',
     'PhutilConsoleBlock' => 'console/view/PhutilConsoleBlock.php',
     'PhutilConsoleError' => 'console/view/PhutilConsoleError.php',
     'PhutilConsoleFormatter' => 'console/PhutilConsoleFormatter.php',
     'PhutilConsoleInfo' => 'console/view/PhutilConsoleInfo.php',
     'PhutilConsoleList' => 'console/view/PhutilConsoleList.php',
     'PhutilConsoleLogLine' => 'console/view/PhutilConsoleLogLine.php',
     'PhutilConsoleMessage' => 'console/PhutilConsoleMessage.php',
     'PhutilConsoleMetrics' => 'console/PhutilConsoleMetrics.php',
     'PhutilConsoleMetricsSignalHandler' => 'future/exec/PhutilConsoleMetricsSignalHandler.php',
     'PhutilConsoleProgressBar' => 'console/PhutilConsoleProgressBar.php',
     'PhutilConsoleProgressSink' => 'progress/PhutilConsoleProgressSink.php',
     'PhutilConsoleServer' => 'console/PhutilConsoleServer.php',
     'PhutilConsoleServerChannel' => 'console/PhutilConsoleServerChannel.php',
     'PhutilConsoleSkip' => 'console/view/PhutilConsoleSkip.php',
     'PhutilConsoleStdinNotInteractiveException' => 'console/PhutilConsoleStdinNotInteractiveException.php',
     'PhutilConsoleTable' => 'console/view/PhutilConsoleTable.php',
     'PhutilConsoleView' => 'console/view/PhutilConsoleView.php',
     'PhutilConsoleWarning' => 'console/view/PhutilConsoleWarning.php',
     'PhutilConsoleWrapTestCase' => 'console/__tests__/PhutilConsoleWrapTestCase.php',
     'PhutilCowsay' => 'utils/PhutilCowsay.php',
     'PhutilCowsayTestCase' => 'utils/__tests__/PhutilCowsayTestCase.php',
     'PhutilCsprintfTestCase' => 'xsprintf/__tests__/PhutilCsprintfTestCase.php',
     'PhutilCzechLocale' => 'internationalization/locales/PhutilCzechLocale.php',
     'PhutilDOMNode' => 'parser/html/PhutilDOMNode.php',
     'PhutilDeferredLog' => 'filesystem/PhutilDeferredLog.php',
     'PhutilDeferredLogTestCase' => 'filesystem/__tests__/PhutilDeferredLogTestCase.php',
     'PhutilDiffBinaryAnalyzer' => 'filesystem/binary/PhutilDiffBinaryAnalyzer.php',
     'PhutilDirectedScalarGraph' => 'utils/PhutilDirectedScalarGraph.php',
     'PhutilDirectoryFixture' => 'filesystem/PhutilDirectoryFixture.php',
     'PhutilDocblockParser' => 'parser/PhutilDocblockParser.php',
     'PhutilDocblockParserTestCase' => 'parser/__tests__/PhutilDocblockParserTestCase.php',
     'PhutilEditDistanceMatrix' => 'utils/PhutilEditDistanceMatrix.php',
     'PhutilEditDistanceMatrixTestCase' => 'utils/__tests__/PhutilEditDistanceMatrixTestCase.php',
     'PhutilEditorConfig' => 'parser/PhutilEditorConfig.php',
     'PhutilEditorConfigTestCase' => 'parser/__tests__/PhutilEditorConfigTestCase.php',
     'PhutilEmailAddress' => 'parser/PhutilEmailAddress.php',
     'PhutilEmailAddressTestCase' => 'parser/__tests__/PhutilEmailAddressTestCase.php',
     'PhutilEmojiLocale' => 'internationalization/locales/PhutilEmojiLocale.php',
     'PhutilEnglishCanadaLocale' => 'internationalization/locales/PhutilEnglishCanadaLocale.php',
     'PhutilErrorHandler' => 'error/PhutilErrorHandler.php',
     'PhutilErrorHandlerTestCase' => 'error/__tests__/PhutilErrorHandlerTestCase.php',
     'PhutilErrorLog' => 'filesystem/PhutilErrorLog.php',
     'PhutilErrorTrap' => 'error/PhutilErrorTrap.php',
     'PhutilEvent' => 'events/PhutilEvent.php',
     'PhutilEventConstants' => 'events/constant/PhutilEventConstants.php',
     'PhutilEventEngine' => 'events/PhutilEventEngine.php',
     'PhutilEventListener' => 'events/PhutilEventListener.php',
     'PhutilEventType' => 'events/constant/PhutilEventType.php',
     'PhutilExampleBufferedIterator' => 'utils/PhutilExampleBufferedIterator.php',
     'PhutilExecChannel' => 'channel/PhutilExecChannel.php',
     'PhutilExecPassthru' => 'future/exec/PhutilExecPassthru.php',
     'PhutilExecutableFuture' => 'future/exec/PhutilExecutableFuture.php',
     'PhutilExecutionEnvironment' => 'utils/PhutilExecutionEnvironment.php',
     'PhutilFileLock' => 'filesystem/PhutilFileLock.php',
     'PhutilFileLockTestCase' => 'filesystem/__tests__/PhutilFileLockTestCase.php',
     'PhutilFrenchLocale' => 'internationalization/locales/PhutilFrenchLocale.php',
     'PhutilGermanLocale' => 'internationalization/locales/PhutilGermanLocale.php',
     'PhutilGitBinaryAnalyzer' => 'filesystem/binary/PhutilGitBinaryAnalyzer.php',
     'PhutilGitHubFuture' => 'future/github/PhutilGitHubFuture.php',
     'PhutilGitHubResponse' => 'future/github/PhutilGitHubResponse.php',
     'PhutilGitURI' => 'parser/PhutilGitURI.php',
     'PhutilGitURITestCase' => 'parser/__tests__/PhutilGitURITestCase.php',
     'PhutilGitsprintfTestCase' => 'xsprintf/__tests__/PhutilGitsprintfTestCase.php',
     'PhutilHTMLParser' => 'parser/html/PhutilHTMLParser.php',
     'PhutilHTMLParserTestCase' => 'parser/html/__tests__/PhutilHTMLParserTestCase.php',
     'PhutilHTTPEngineExtension' => 'future/http/PhutilHTTPEngineExtension.php',
     'PhutilHTTPResponse' => 'parser/http/PhutilHTTPResponse.php',
     'PhutilHTTPResponseParser' => 'parser/http/PhutilHTTPResponseParser.php',
     'PhutilHTTPResponseParserTestCase' => 'parser/http/__tests__/PhutilHTTPResponseParserTestCase.php',
     'PhutilHashingIterator' => 'utils/PhutilHashingIterator.php',
     'PhutilHashingIteratorTestCase' => 'utils/__tests__/PhutilHashingIteratorTestCase.php',
     'PhutilHelpArgumentWorkflow' => 'parser/argument/workflow/PhutilHelpArgumentWorkflow.php',
     'PhutilHgsprintfTestCase' => 'xsprintf/__tests__/PhutilHgsprintfTestCase.php',
     'PhutilINIParserException' => 'parser/exception/PhutilINIParserException.php',
     'PhutilIPAddress' => 'ip/PhutilIPAddress.php',
     'PhutilIPAddressTestCase' => 'ip/__tests__/PhutilIPAddressTestCase.php',
     'PhutilIPv4Address' => 'ip/PhutilIPv4Address.php',
     'PhutilIPv6Address' => 'ip/PhutilIPv6Address.php',
     'PhutilInteractiveEditor' => 'console/PhutilInteractiveEditor.php',
     'PhutilInvalidRuleParserGeneratorException' => 'parser/generator/exception/PhutilInvalidRuleParserGeneratorException.php',
     'PhutilInvalidStateException' => 'exception/PhutilInvalidStateException.php',
     'PhutilInvalidStateExceptionTestCase' => 'exception/__tests__/PhutilInvalidStateExceptionTestCase.php',
     'PhutilIrreducibleRuleParserGeneratorException' => 'parser/generator/exception/PhutilIrreducibleRuleParserGeneratorException.php',
     'PhutilJSON' => 'parser/PhutilJSON.php',
     'PhutilJSONFragmentLexer' => 'lexer/PhutilJSONFragmentLexer.php',
     'PhutilJSONParser' => 'parser/PhutilJSONParser.php',
     'PhutilJSONParserException' => 'parser/exception/PhutilJSONParserException.php',
     'PhutilJSONParserTestCase' => 'parser/__tests__/PhutilJSONParserTestCase.php',
     'PhutilJSONProtocolChannel' => 'channel/PhutilJSONProtocolChannel.php',
     'PhutilJSONProtocolChannelTestCase' => 'channel/__tests__/PhutilJSONProtocolChannelTestCase.php',
     'PhutilJSONTestCase' => 'parser/__tests__/PhutilJSONTestCase.php',
     'PhutilJavaFragmentLexer' => 'lexer/PhutilJavaFragmentLexer.php',
     'PhutilKoreanLocale' => 'internationalization/locales/PhutilKoreanLocale.php',
     'PhutilLanguageGuesser' => 'parser/PhutilLanguageGuesser.php',
     'PhutilLanguageGuesserTestCase' => 'parser/__tests__/PhutilLanguageGuesserTestCase.php',
     'PhutilLexer' => 'lexer/PhutilLexer.php',
     'PhutilLibraryConflictException' => 'init/lib/PhutilLibraryConflictException.php',
     'PhutilLibraryMapBuilder' => 'moduleutils/PhutilLibraryMapBuilder.php',
     'PhutilLibraryTestCase' => '__tests__/PhutilLibraryTestCase.php',
     'PhutilLocale' => 'internationalization/PhutilLocale.php',
     'PhutilLocaleTestCase' => 'internationalization/__tests__/PhutilLocaleTestCase.php',
     'PhutilLock' => 'filesystem/PhutilLock.php',
     'PhutilLockException' => 'filesystem/PhutilLockException.php',
     'PhutilLogFileChannel' => 'channel/PhutilLogFileChannel.php',
     'PhutilLunarPhase' => 'utils/PhutilLunarPhase.php',
     'PhutilLunarPhaseTestCase' => 'utils/__tests__/PhutilLunarPhaseTestCase.php',
     'PhutilMercurialBinaryAnalyzer' => 'filesystem/binary/PhutilMercurialBinaryAnalyzer.php',
     'PhutilMethodNotImplementedException' => 'error/PhutilMethodNotImplementedException.php',
     'PhutilMetricsChannel' => 'channel/PhutilMetricsChannel.php',
     'PhutilMissingSymbolException' => 'init/lib/PhutilMissingSymbolException.php',
     'PhutilModuleUtilsTestCase' => 'init/lib/__tests__/PhutilModuleUtilsTestCase.php',
     'PhutilNumber' => 'internationalization/PhutilNumber.php',
     'PhutilOAuth1Future' => 'future/oauth/PhutilOAuth1Future.php',
     'PhutilOAuth1FutureTestCase' => 'future/oauth/__tests__/PhutilOAuth1FutureTestCase.php',
     'PhutilOpaqueEnvelope' => 'error/PhutilOpaqueEnvelope.php',
     'PhutilOpaqueEnvelopeKey' => 'error/PhutilOpaqueEnvelopeKey.php',
     'PhutilOpaqueEnvelopeTestCase' => 'error/__tests__/PhutilOpaqueEnvelopeTestCase.php',
     'PhutilPHPFragmentLexer' => 'lexer/PhutilPHPFragmentLexer.php',
     'PhutilPHPFragmentLexerTestCase' => 'lexer/__tests__/PhutilPHPFragmentLexerTestCase.php',
     'PhutilPHPObjectProtocolChannel' => 'channel/PhutilPHPObjectProtocolChannel.php',
     'PhutilPHPObjectProtocolChannelTestCase' => 'channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php',
     'PhutilParserGenerator' => 'parser/PhutilParserGenerator.php',
     'PhutilParserGeneratorException' => 'parser/generator/exception/PhutilParserGeneratorException.php',
     'PhutilParserGeneratorTestCase' => 'parser/__tests__/PhutilParserGeneratorTestCase.php',
     'PhutilPayPalAPIFuture' => 'future/paypal/PhutilPayPalAPIFuture.php',
     'PhutilPerson' => 'internationalization/PhutilPerson.php',
     'PhutilPersonTest' => 'internationalization/__tests__/PhutilPersonTest.php',
     'PhutilPhtTestCase' => 'internationalization/__tests__/PhutilPhtTestCase.php',
     'PhutilPirateEnglishLocale' => 'internationalization/locales/PhutilPirateEnglishLocale.php',
     'PhutilPortugueseBrazilLocale' => 'internationalization/locales/PhutilPortugueseBrazilLocale.php',
     'PhutilPortuguesePortugalLocale' => 'internationalization/locales/PhutilPortuguesePortugalLocale.php',
     'PhutilPostmarkFuture' => 'future/postmark/PhutilPostmarkFuture.php',
     'PhutilPregsprintfTestCase' => 'xsprintf/__tests__/PhutilPregsprintfTestCase.php',
     'PhutilProcessQuery' => 'filesystem/PhutilProcessQuery.php',
     'PhutilProcessRef' => 'filesystem/PhutilProcessRef.php',
     'PhutilProcessRefTestCase' => 'filesystem/__tests__/PhutilProcessRefTestCase.php',
     'PhutilProgressSink' => 'progress/PhutilProgressSink.php',
     'PhutilProtocolChannel' => 'channel/PhutilProtocolChannel.php',
     'PhutilProxyException' => 'error/PhutilProxyException.php',
     'PhutilProxyIterator' => 'utils/PhutilProxyIterator.php',
     'PhutilPygmentizeBinaryAnalyzer' => 'filesystem/binary/PhutilPygmentizeBinaryAnalyzer.php',
     'PhutilPythonFragmentLexer' => 'lexer/PhutilPythonFragmentLexer.php',
     'PhutilQueryStringParser' => 'parser/PhutilQueryStringParser.php',
     'PhutilQueryStringParserTestCase' => 'parser/__tests__/PhutilQueryStringParserTestCase.php',
     'PhutilRawEnglishLocale' => 'internationalization/locales/PhutilRawEnglishLocale.php',
     'PhutilReadableSerializer' => 'readableserializer/PhutilReadableSerializer.php',
     'PhutilReadableSerializerTestCase' => 'readableserializer/__tests__/PhutilReadableSerializerTestCase.php',
     'PhutilRegexException' => 'exception/PhutilRegexException.php',
     'PhutilRope' => 'utils/PhutilRope.php',
     'PhutilRopeTestCase' => 'utils/__tests__/PhutilRopeTestCase.php',
     'PhutilServiceProfiler' => 'serviceprofiler/PhutilServiceProfiler.php',
     'PhutilShellLexer' => 'lexer/PhutilShellLexer.php',
     'PhutilShellLexerTestCase' => 'lexer/__tests__/PhutilShellLexerTestCase.php',
     'PhutilSignalHandler' => 'future/exec/PhutilSignalHandler.php',
     'PhutilSignalRouter' => 'future/exec/PhutilSignalRouter.php',
     'PhutilSimpleOptions' => 'parser/PhutilSimpleOptions.php',
     'PhutilSimpleOptionsLexer' => 'lexer/PhutilSimpleOptionsLexer.php',
     'PhutilSimpleOptionsLexerTestCase' => 'lexer/__tests__/PhutilSimpleOptionsLexerTestCase.php',
     'PhutilSimpleOptionsTestCase' => 'parser/__tests__/PhutilSimpleOptionsTestCase.php',
     'PhutilSimplifiedChineseLocale' => 'internationalization/locales/PhutilSimplifiedChineseLocale.php',
     'PhutilSlackFuture' => 'future/slack/PhutilSlackFuture.php',
     'PhutilSocketChannel' => 'channel/PhutilSocketChannel.php',
     'PhutilSortVector' => 'utils/PhutilSortVector.php',
     'PhutilSpanishSpainLocale' => 'internationalization/locales/PhutilSpanishSpainLocale.php',
     'PhutilStreamIterator' => 'utils/PhutilStreamIterator.php',
     'PhutilSubversionBinaryAnalyzer' => 'filesystem/binary/PhutilSubversionBinaryAnalyzer.php',
     'PhutilSymbolLoader' => 'symbols/PhutilSymbolLoader.php',
     'PhutilSystem' => 'utils/PhutilSystem.php',
     'PhutilSystemTestCase' => 'utils/__tests__/PhutilSystemTestCase.php',
     'PhutilTerminalString' => 'xsprintf/PhutilTerminalString.php',
     'PhutilTestCase' => 'unit/engine/phutil/PhutilTestCase.php',
     'PhutilTestCaseTestCase' => 'unit/engine/phutil/testcase/PhutilTestCaseTestCase.php',
     'PhutilTestPhobject' => 'object/__tests__/PhutilTestPhobject.php',
     'PhutilTestSkippedException' => 'unit/engine/phutil/testcase/PhutilTestSkippedException.php',
     'PhutilTestTerminatedException' => 'unit/engine/phutil/testcase/PhutilTestTerminatedException.php',
     'PhutilTraditionalChineseLocale' => 'internationalization/locales/PhutilTraditionalChineseLocale.php',
     'PhutilTranslation' => 'internationalization/PhutilTranslation.php',
     'PhutilTranslationTestCase' => 'internationalization/__tests__/PhutilTranslationTestCase.php',
     'PhutilTranslator' => 'internationalization/PhutilTranslator.php',
     'PhutilTranslatorTestCase' => 'internationalization/__tests__/PhutilTranslatorTestCase.php',
     'PhutilTsprintfTestCase' => 'xsprintf/__tests__/PhutilTsprintfTestCase.php',
     'PhutilTwitchFuture' => 'future/twitch/PhutilTwitchFuture.php',
     'PhutilTypeCheckException' => 'parser/exception/PhutilTypeCheckException.php',
     'PhutilTypeExtraParametersException' => 'parser/exception/PhutilTypeExtraParametersException.php',
     'PhutilTypeLexer' => 'lexer/PhutilTypeLexer.php',
     'PhutilTypeMissingParametersException' => 'parser/exception/PhutilTypeMissingParametersException.php',
     'PhutilTypeSpec' => 'parser/PhutilTypeSpec.php',
     'PhutilTypeSpecTestCase' => 'parser/__tests__/PhutilTypeSpecTestCase.php',
     'PhutilURI' => 'parser/PhutilURI.php',
     'PhutilURITestCase' => 'parser/__tests__/PhutilURITestCase.php',
     'PhutilUSEnglishLocale' => 'internationalization/locales/PhutilUSEnglishLocale.php',
     'PhutilUTF8StringTruncator' => 'utils/PhutilUTF8StringTruncator.php',
     'PhutilUTF8TestCase' => 'utils/__tests__/PhutilUTF8TestCase.php',
     'PhutilUnitTestEngine' => 'unit/engine/PhutilUnitTestEngine.php',
     'PhutilUnitTestEngineTestCase' => 'unit/engine/__tests__/PhutilUnitTestEngineTestCase.php',
     'PhutilUnknownSymbolParserGeneratorException' => 'parser/generator/exception/PhutilUnknownSymbolParserGeneratorException.php',
     'PhutilUnreachableRuleParserGeneratorException' => 'parser/generator/exception/PhutilUnreachableRuleParserGeneratorException.php',
     'PhutilUnreachableTerminalParserGeneratorException' => 'parser/generator/exception/PhutilUnreachableTerminalParserGeneratorException.php',
     'PhutilUrisprintfTestCase' => 'xsprintf/__tests__/PhutilUrisprintfTestCase.php',
     'PhutilUtilsTestCase' => 'utils/__tests__/PhutilUtilsTestCase.php',
     'PhutilVeryWowEnglishLocale' => 'internationalization/locales/PhutilVeryWowEnglishLocale.php',
     'PhutilWordPressFuture' => 'future/wordpress/PhutilWordPressFuture.php',
     'PhutilXHPASTBinary' => 'parser/xhpast/bin/PhutilXHPASTBinary.php',
+    'PlatformSymbols' => 'platform/PlatformSymbols.php',
     'PytestTestEngine' => 'unit/engine/PytestTestEngine.php',
     'TempFile' => 'filesystem/TempFile.php',
     'TestAbstractDirectedGraph' => 'utils/__tests__/TestAbstractDirectedGraph.php',
     'XHPASTNode' => 'parser/xhpast/api/XHPASTNode.php',
     'XHPASTNodeTestCase' => 'parser/xhpast/api/__tests__/XHPASTNodeTestCase.php',
     'XHPASTSyntaxErrorException' => 'parser/xhpast/api/XHPASTSyntaxErrorException.php',
     'XHPASTToken' => 'parser/xhpast/api/XHPASTToken.php',
     'XHPASTTree' => 'parser/xhpast/api/XHPASTTree.php',
     'XHPASTTreeTestCase' => 'parser/xhpast/api/__tests__/XHPASTTreeTestCase.php',
     'XUnitTestEngine' => 'unit/engine/XUnitTestEngine.php',
     'XUnitTestResultParserTestCase' => 'unit/parser/__tests__/XUnitTestResultParserTestCase.php',
     'XsprintfUnknownConversionException' => 'xsprintf/exception/XsprintfUnknownConversionException.php',
   ),
   'function' => array(
     '__phutil_autoload' => 'init/init-library.php',
     'array_fuse' => 'utils/utils.php',
     'array_interleave' => 'utils/utils.php',
     'array_mergev' => 'utils/utils.php',
     'array_select_keys' => 'utils/utils.php',
     'assert_instances_of' => 'utils/utils.php',
     'assert_same_keys' => 'utils/utils.php',
     'assert_stringlike' => 'utils/utils.php',
     'coalesce' => 'utils/utils.php',
     'csprintf' => 'xsprintf/csprintf.php',
     'exec_manual' => 'future/exec/execx.php',
     'execx' => 'future/exec/execx.php',
     'gitsprintf' => 'xsprintf/gitsprintf.php',
     'head' => 'utils/utils.php',
     'head_key' => 'utils/utils.php',
     'hgsprintf' => 'xsprintf/hgsprintf.php',
     'id' => 'utils/utils.php',
     'idx' => 'utils/utils.php',
     'idxv' => 'utils/utils.php',
     'ifilter' => 'utils/utils.php',
     'igroup' => 'utils/utils.php',
     'ipull' => 'utils/utils.php',
     'isort' => 'utils/utils.php',
     'jsprintf' => 'xsprintf/jsprintf.php',
     'last' => 'utils/utils.php',
     'last_key' => 'utils/utils.php',
     'ldap_sprintf' => 'xsprintf/ldapsprintf.php',
     'mfilter' => 'utils/utils.php',
     'mgroup' => 'utils/utils.php',
     'mpull' => 'utils/utils.php',
     'msort' => 'utils/utils.php',
     'msortv' => 'utils/utils.php',
     'msortv_internal' => 'utils/utils.php',
     'msortv_natural' => 'utils/utils.php',
     'newv' => 'utils/utils.php',
     'nonempty' => 'utils/utils.php',
     'phlog' => 'error/phlog.php',
     'pht' => 'internationalization/pht.php',
+    'pht_list' => 'internationalization/pht.php',
     'phutil_build_http_querystring' => 'utils/utils.php',
     'phutil_build_http_querystring_from_pairs' => 'utils/utils.php',
     'phutil_censor_credentials' => 'utils/utils.php',
     'phutil_console_confirm' => 'console/format.php',
     'phutil_console_format' => 'console/format.php',
     'phutil_console_get_terminal_width' => 'console/format.php',
     'phutil_console_prompt' => 'console/format.php',
     'phutil_console_require_tty' => 'console/format.php',
     'phutil_console_select' => 'console/format.php',
     'phutil_console_wrap' => 'console/format.php',
     'phutil_count' => 'internationalization/pht.php',
     'phutil_date_format' => 'utils/viewutils.php',
     'phutil_decode_mime_header' => 'utils/utils.php',
     'phutil_describe_type' => 'utils/utils.php',
     'phutil_encode_log' => 'utils/utils.php',
     'phutil_error_listener_example' => 'error/phlog.php',
     'phutil_escape_uri' => 'utils/utils.php',
     'phutil_escape_uri_path_component' => 'utils/utils.php',
     'phutil_fnmatch' => 'utils/utils.php',
     'phutil_format_bytes' => 'utils/viewutils.php',
     'phutil_format_relative_time' => 'utils/viewutils.php',
     'phutil_format_relative_time_detailed' => 'utils/viewutils.php',
     'phutil_format_units_generic' => 'utils/viewutils.php',
     'phutil_fwrite_nonblocking_stream' => 'utils/utils.php',
     'phutil_get_current_library_name' => 'init/lib/moduleutils.php',
     'phutil_get_library_name_for_root' => 'init/lib/moduleutils.php',
     'phutil_get_library_root' => 'init/lib/moduleutils.php',
     'phutil_get_library_root_for_path' => 'init/lib/moduleutils.php',
     'phutil_get_signal_name' => 'future/exec/execx.php',
     'phutil_get_system_locale' => 'utils/utf8.php',
     'phutil_glue' => 'utils/utils.php',
     'phutil_hashes_are_identical' => 'utils/utils.php',
     'phutil_http_parameter_pair' => 'utils/utils.php',
     'phutil_ini_decode' => 'utils/utils.php',
     'phutil_is_hiphop_runtime' => 'utils/utils.php',
     'phutil_is_interactive' => 'utils/utils.php',
     'phutil_is_natural_list' => 'utils/utils.php',
     'phutil_is_noninteractive' => 'utils/utils.php',
     'phutil_is_system_locale_available' => 'utils/utf8.php',
     'phutil_is_utf8' => 'utils/utf8.php',
     'phutil_is_utf8_slowly' => 'utils/utf8.php',
     'phutil_is_utf8_with_only_bmp_characters' => 'utils/utf8.php',
     'phutil_is_windows' => 'utils/utils.php',
     'phutil_json_decode' => 'utils/utils.php',
     'phutil_json_encode' => 'utils/utils.php',
     'phutil_load_library' => 'init/lib/moduleutils.php',
     'phutil_loggable_string' => 'utils/utils.php',
     'phutil_microseconds_since' => 'utils/utils.php',
+    'phutil_nonempty_scalar' => 'utils/utils.php',
+    'phutil_nonempty_string' => 'utils/utils.php',
+    'phutil_nonempty_stringlike' => 'utils/utils.php',
     'phutil_parse_bytes' => 'utils/viewutils.php',
     'phutil_partition' => 'utils/utils.php',
     'phutil_passthru' => 'future/exec/execx.php',
     'phutil_person' => 'internationalization/pht.php',
     'phutil_preg_match' => 'utils/utils.php',
     'phutil_preg_match_all' => 'utils/utils.php',
     'phutil_raise_preg_exception' => 'utils/utils.php',
     'phutil_register_library' => 'init/lib/core.php',
     'phutil_register_library_map' => 'init/lib/core.php',
     'phutil_set_system_locale' => 'utils/utf8.php',
     'phutil_split_lines' => 'utils/utils.php',
     'phutil_string_cast' => 'utils/utils.php',
     'phutil_unescape_uri_path_component' => 'utils/utils.php',
     'phutil_units' => 'utils/utils.php',
     'phutil_utf8_console_strlen' => 'utils/utf8.php',
     'phutil_utf8_convert' => 'utils/utf8.php',
     'phutil_utf8_encode_codepoint' => 'utils/utf8.php',
     'phutil_utf8_hard_wrap' => 'utils/utf8.php',
     'phutil_utf8_hard_wrap_html' => 'utils/utf8.php',
     'phutil_utf8_is_cjk' => 'utils/utf8.php',
     'phutil_utf8_is_combining_character' => 'utils/utf8.php',
     'phutil_utf8_strlen' => 'utils/utf8.php',
     'phutil_utf8_strtolower' => 'utils/utf8.php',
     'phutil_utf8_strtoupper' => 'utils/utf8.php',
     'phutil_utf8_strtr' => 'utils/utf8.php',
     'phutil_utf8_ucwords' => 'utils/utf8.php',
     'phutil_utf8ize' => 'utils/utf8.php',
     'phutil_utf8v' => 'utils/utf8.php',
     'phutil_utf8v_codepoints' => 'utils/utf8.php',
     'phutil_utf8v_combine_characters' => 'utils/utf8.php',
     'phutil_utf8v_combined' => 'utils/utf8.php',
     'phutil_validate_json' => 'utils/utils.php',
     'phutil_var_export' => 'utils/utils.php',
     'ppull' => 'utils/utils.php',
     'pregsprintf' => 'xsprintf/pregsprintf.php',
     'tsprintf' => 'xsprintf/tsprintf.php',
     'urisprintf' => 'xsprintf/urisprintf.php',
     'vcsprintf' => 'xsprintf/csprintf.php',
     'vjsprintf' => 'xsprintf/jsprintf.php',
     'vurisprintf' => 'xsprintf/urisprintf.php',
     'xhp_parser_node_constants' => 'parser/xhpast/parser_nodes.php',
     'xhpast_parser_token_constants' => 'parser/xhpast/parser_tokens.php',
     'xsprintf' => 'xsprintf/xsprintf.php',
     'xsprintf_callback_example' => 'xsprintf/xsprintf.php',
     'xsprintf_command' => 'xsprintf/csprintf.php',
     'xsprintf_git' => 'xsprintf/gitsprintf.php',
     'xsprintf_javascript' => 'xsprintf/jsprintf.php',
     'xsprintf_ldap' => 'xsprintf/ldapsprintf.php',
     'xsprintf_mercurial' => 'xsprintf/hgsprintf.php',
     'xsprintf_regex' => 'xsprintf/pregsprintf.php',
     'xsprintf_terminal' => 'xsprintf/tsprintf.php',
     'xsprintf_uri' => 'xsprintf/urisprintf.php',
   ),
   'xmap' => array(
     'AASTNode' => 'Phobject',
     'AASTNodeList' => array(
       'Phobject',
       'Countable',
       'Iterator',
     ),
     'AASTToken' => 'Phobject',
     'AASTTree' => 'Phobject',
     'AbstractDirectedGraph' => 'Phobject',
     'AbstractDirectedGraphTestCase' => 'PhutilTestCase',
     'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAlias' => 'Phobject',
     'ArcanistAliasEffect' => 'Phobject',
     'ArcanistAliasEngine' => 'Phobject',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAliasWorkflow' => 'ArcanistWorkflow',
     'ArcanistAliasesConfigOption' => 'ArcanistMultiSourceConfigOption',
     'ArcanistAmendWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistAnoidWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistArcConfigurationEngineExtension' => 'ArcanistConfigurationEngineExtension',
     'ArcanistArcToolset' => 'ArcanistToolset',
     'ArcanistArcWorkflow' => 'ArcanistWorkflow',
     'ArcanistArrayCombineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArraySeparatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArrayValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBaseCommitParser' => 'Phobject',
     'ArcanistBaseCommitParserTestCase' => 'PhutilTestCase',
     'ArcanistBaseXHPASTLinter' => 'ArcanistFutureLinter',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBlindlyTrustHTTPEngineExtension' => 'PhutilHTTPEngineExtension',
     'ArcanistBookmarksWorkflow' => 'ArcanistMarkersWorkflow',
     'ArcanistBoolConfigOption' => 'ArcanistSingleSourceConfigOption',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBranchesWorkflow' => 'ArcanistMarkersWorkflow',
     'ArcanistBrowseCommitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistBrowseCommitURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowseObjectNameURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowsePathURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowseRef' => 'ArcanistRef',
     'ArcanistBrowseRefInspector' => 'ArcanistRefInspector',
     'ArcanistBrowseRevisionURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowseURIHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistBrowseURIRef' => 'ArcanistRef',
     'ArcanistBrowseWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistBuildBuildplanHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistBuildPlanRef' => 'ArcanistRef',
     'ArcanistBuildPlanSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistBuildRef' => 'ArcanistRef',
     'ArcanistBuildSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistBuildableBuildsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistBuildableRef' => 'ArcanistRef',
     'ArcanistBuildableSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistBundle' => 'Phobject',
     'ArcanistBundleTestCase' => 'PhutilTestCase',
     'ArcanistCSSLintLinter' => 'ArcanistExternalLinter',
     'ArcanistCSSLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCSharpLinter' => 'ArcanistLinter',
     'ArcanistCallConduitWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistCallParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCapabilityNotSupportedException' => 'Exception',
     'ArcanistCastSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCheckstyleXMLLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistChmodLinter' => 'ArcanistLinter',
     'ArcanistChmodLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistClassExtendsObjectXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistClassNameLiteralXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCloseRevisionWorkflow' => 'ArcanistWorkflow',
     'ArcanistClosureLinter' => 'ArcanistExternalLinter',
     'ArcanistClosureLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCoffeeLintLinter' => 'ArcanistExternalLinter',
     'ArcanistCoffeeLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCommand' => 'Phobject',
     'ArcanistCommentRemover' => 'Phobject',
     'ArcanistCommentRemoverTestCase' => 'PhutilTestCase',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCommitGraph' => 'Phobject',
     'ArcanistCommitGraphPartition' => 'Phobject',
     'ArcanistCommitGraphPartitionQuery' => 'Phobject',
     'ArcanistCommitGraphQuery' => 'Phobject',
     'ArcanistCommitGraphSet' => 'Phobject',
     'ArcanistCommitGraphSetQuery' => 'Phobject',
     'ArcanistCommitGraphSetTreeView' => 'Phobject',
     'ArcanistCommitGraphSetView' => 'Phobject',
     'ArcanistCommitGraphTestCase' => 'PhutilTestCase',
     'ArcanistCommitNode' => 'Phobject',
     'ArcanistCommitRef' => 'ArcanistRef',
     'ArcanistCommitSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistCommitSymbolRefInspector' => 'ArcanistRefInspector',
     'ArcanistCommitUpstreamHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistComposerLinter' => 'ArcanistLinter',
     'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistConduitAuthenticationException' => 'Exception',
     'ArcanistConduitCallFuture' => 'FutureProxy',
     'ArcanistConduitEngine' => 'Phobject',
     'ArcanistConduitException' => 'Exception',
     'ArcanistConfigOption' => 'Phobject',
     'ArcanistConfiguration' => 'Phobject',
     'ArcanistConfigurationDrivenLintEngine' => 'ArcanistLintEngine',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'ArcanistUnitTestEngine',
     'ArcanistConfigurationEngine' => 'Phobject',
     'ArcanistConfigurationEngineExtension' => 'Phobject',
     'ArcanistConfigurationManager' => 'Phobject',
     'ArcanistConfigurationSource' => 'Phobject',
     'ArcanistConfigurationSourceList' => 'Phobject',
     'ArcanistConfigurationSourceValue' => 'Phobject',
     'ArcanistConsoleLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistConsoleLintRendererTestCase' => 'PhutilTestCase',
     'ArcanistConstructorParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistContinueInsideSwitchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistControlStatementSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistControlStatementSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCoverWorkflow' => 'ArcanistWorkflow',
     'ArcanistCppcheckLinter' => 'ArcanistExternalLinter',
     'ArcanistCppcheckLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCpplintLinter' => 'ArcanistExternalLinter',
     'ArcanistCpplintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDeclarationParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDefaultParametersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDefaultParametersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDefaultsConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
     'ArcanistDeprecationXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDictionaryConfigurationSource' => 'ArcanistConfigurationSource',
     'ArcanistDiffByteSizeException' => 'Exception',
     'ArcanistDiffChange' => 'Phobject',
     'ArcanistDiffChangeType' => 'Phobject',
     'ArcanistDiffHunk' => 'Phobject',
     'ArcanistDiffParser' => 'Phobject',
     'ArcanistDiffParserTestCase' => 'PhutilTestCase',
     'ArcanistDiffUtils' => 'Phobject',
     'ArcanistDiffUtilsTestCase' => 'PhutilTestCase',
     'ArcanistDiffVectorNode' => 'Phobject',
     'ArcanistDiffVectorTree' => 'Phobject',
     'ArcanistDiffWorkflow' => 'ArcanistWorkflow',
     'ArcanistDifferentialCommitMessage' => 'Phobject',
     'ArcanistDifferentialCommitMessageParserException' => 'Exception',
     'ArcanistDifferentialDependencyGraph' => 'AbstractDirectedGraph',
     'ArcanistDifferentialRevisionHash' => 'Phobject',
     'ArcanistDifferentialRevisionStatus' => 'Phobject',
     'ArcanistDoubleQuoteXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDownloadWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDynamicDefineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEachUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEachUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistElseIfUsageXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEmptyFileXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEmptyStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEventType' => 'PhutilEventType',
     'ArcanistExitExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistExportWorkflow' => 'ArcanistWorkflow',
     'ArcanistExternalLinter' => 'ArcanistFutureLinter',
     'ArcanistExternalLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistExtractUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFileConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistFileDataRef' => 'Phobject',
     'ArcanistFileRef' => 'ArcanistRef',
     'ArcanistFileSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistFileUploader' => 'Phobject',
     'ArcanistFilenameLinter' => 'ArcanistLinter',
     'ArcanistFilenameLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistFilesystemAPI' => 'ArcanistRepositoryAPI',
     'ArcanistFilesystemConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
     'ArcanistFilesystemWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistFlake8Linter' => 'ArcanistExternalLinter',
     'ArcanistFlake8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistFormattedStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFutureLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistGetConfigWorkflow' => 'ArcanistWorkflow',
     'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
     'ArcanistGitCommitGraphQuery' => 'ArcanistCommitGraphQuery',
     'ArcanistGitCommitMessageHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGitLandEngine' => 'ArcanistLandEngine',
     'ArcanistGitLocalState' => 'ArcanistRepositoryLocalState',
     'ArcanistGitRawCommit' => 'Phobject',
     'ArcanistGitRawCommitTestCase' => 'PhutilTestCase',
     'ArcanistGitRepositoryMarkerQuery' => 'ArcanistRepositoryMarkerQuery',
     'ArcanistGitRepositoryRemoteQuery' => 'ArcanistRepositoryRemoteQuery',
     'ArcanistGitUpstreamPath' => 'Phobject',
     'ArcanistGitWorkEngine' => 'ArcanistWorkEngine',
     'ArcanistGitWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
     'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
     'ArcanistGridCell' => 'Phobject',
     'ArcanistGridColumn' => 'Phobject',
     'ArcanistGridRow' => 'Phobject',
     'ArcanistGridView' => 'Phobject',
     'ArcanistHLintLinter' => 'ArcanistExternalLinter',
     'ArcanistHLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistHardpoint' => 'Phobject',
     'ArcanistHardpointEngine' => 'Phobject',
     'ArcanistHardpointFutureList' => 'Phobject',
     'ArcanistHardpointList' => 'Phobject',
     'ArcanistHardpointObject' => 'Phobject',
     'ArcanistHardpointQuery' => 'Phobject',
     'ArcanistHardpointRequest' => 'Phobject',
     'ArcanistHardpointRequestList' => 'Phobject',
     'ArcanistHardpointTask' => 'Phobject',
     'ArcanistHardpointTaskResult' => 'Phobject',
     'ArcanistHelpWorkflow' => 'ArcanistWorkflow',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistHgClientChannel' => 'PhutilProtocolChannel',
     'ArcanistHgProxyClient' => 'Phobject',
     'ArcanistHgProxyServer' => 'Phobject',
     'ArcanistHgServerChannel' => 'PhutilProtocolChannel',
     'ArcanistHostMemorySnapshot' => 'Phobject',
     'ArcanistHostMemorySnapshotTestCase' => 'PhutilTestCase',
     'ArcanistImplicitConstructorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistImplicitFallthroughXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistImplicitVisibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistImplodeArgumentOrderXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInlineHTMLXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInnerFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInspectWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistInstallCertificateWorkflow' => 'ArcanistWorkflow',
     'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidModifiersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistJSHintLinter' => 'ArcanistExternalLinter',
     'ArcanistJSHintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistJSONLintLinter' => 'ArcanistExternalLinter',
     'ArcanistJSONLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistJSONLinter' => 'ArcanistLinter',
     'ArcanistJSONLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistJscsLinter' => 'ArcanistExternalLinter',
     'ArcanistJscsLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistKeywordCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLandCommit' => 'Phobject',
     'ArcanistLandCommitSet' => 'Phobject',
     'ArcanistLandEngine' => 'ArcanistWorkflowEngine',
     'ArcanistLandPushFailureException' => 'Exception',
     'ArcanistLandSymbol' => 'Phobject',
     'ArcanistLandTarget' => 'Phobject',
     'ArcanistLandWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLesscLinter' => 'ArcanistExternalLinter',
     'ArcanistLesscLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistLiberateWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistLintEngine' => 'Phobject',
     'ArcanistLintMessage' => 'Phobject',
     'ArcanistLintMessageTestCase' => 'PhutilTestCase',
     'ArcanistLintPatcher' => 'Phobject',
     'ArcanistLintRenderer' => 'Phobject',
     'ArcanistLintResult' => 'Phobject',
     'ArcanistLintSeverity' => 'Phobject',
     'ArcanistLintWorkflow' => 'ArcanistWorkflow',
     'ArcanistLinter' => 'Phobject',
     'ArcanistLinterStandard' => 'Phobject',
     'ArcanistLinterStandardTestCase' => 'PhutilTestCase',
     'ArcanistLinterTestCase' => 'PhutilTestCase',
     'ArcanistLintersWorkflow' => 'ArcanistWorkflow',
     'ArcanistListAssignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistListConfigOption' => 'ArcanistSingleSourceConfigOption',
     'ArcanistListWorkflow' => 'ArcanistWorkflow',
     'ArcanistLocalConfigurationSource' => 'ArcanistWorkingCopyConfigurationSource',
     'ArcanistLogEngine' => 'Phobject',
     'ArcanistLogMessage' => 'Phobject',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLookWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistMarkerRef' => 'ArcanistRef',
     'ArcanistMarkersWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
     'ArcanistMercurialCommitGraphQuery' => 'ArcanistCommitGraphQuery',
     'ArcanistMercurialCommitMessageHardpointQuery' => 'ArcanistWorkflowMercurialHardpointQuery',
     'ArcanistMercurialCommitSymbolCommitHardpointQuery' => 'ArcanistWorkflowMercurialHardpointQuery',
     'ArcanistMercurialLandEngine' => 'ArcanistLandEngine',
     'ArcanistMercurialLocalState' => 'ArcanistRepositoryLocalState',
     'ArcanistMercurialParser' => 'Phobject',
     'ArcanistMercurialParserTestCase' => 'PhutilTestCase',
     'ArcanistMercurialRepositoryMarkerQuery' => 'ArcanistRepositoryMarkerQuery',
     'ArcanistMercurialRepositoryRemoteQuery' => 'ArcanistRepositoryRemoteQuery',
     'ArcanistMercurialWorkEngine' => 'ArcanistWorkEngine',
     'ArcanistMercurialWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistMercurialWorkingCopyRevisionHardpointQuery' => 'ArcanistWorkflowMercurialHardpointQuery',
     'ArcanistMergeConflictLinter' => 'ArcanistLinter',
     'ArcanistMergeConflictLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistMessageRevisionHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistMissingArgumentTerminatorException' => 'Exception',
     'ArcanistMissingLinterException' => 'Exception',
     'ArcanistModifierOrderingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistMultiSourceConfigOption' => 'ArcanistConfigOption',
     'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNamingConventionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNestedNamespacesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNoEffectException' => 'ArcanistUsageException',
     'ArcanistNoEngineException' => 'ArcanistUsageException',
     'ArcanistNoLintLinter' => 'ArcanistLinter',
     'ArcanistNoLintLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistNoParentScopeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNoURIConduitException' => 'ArcanistConduitException',
     'ArcanistNonblockingGuard' => 'Phobject',
     'ArcanistNoneLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistObjectListHardpoint' => 'ArcanistHardpoint',
     'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPEP8Linter' => 'ArcanistExternalLinter',
     'ArcanistPEP8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPHPCloseTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPCloseTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPCompatibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPCompatibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPEchoTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPEchoTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPShortTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPShortTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistParentMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistParentMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistParenthesesSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistParenthesesSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistParseStrUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistParseStrUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPartialCatchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPartialCatchXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPasteRef' => 'ArcanistRef',
     'ArcanistPasteSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistPasteWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistPatchWorkflow' => 'ArcanistWorkflow',
     'ArcanistPhpLinter' => 'ArcanistExternalLinter',
     'ArcanistPhpLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPhpcsLinter' => 'ArcanistExternalLinter',
     'ArcanistPhpcsLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPhpunitTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistPhutilLibraryLinter' => 'ArcanistLinter',
     'ArcanistPhutilWorkflow' => 'PhutilArgumentWorkflow',
     'ArcanistPhutilXHPASTLinterStandard' => 'ArcanistLinterStandard',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
+    'ArcanistProductNameLiteralXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistProjectConfigurationSource' => 'ArcanistWorkingCopyConfigurationSource',
     'ArcanistPrompt' => 'Phobject',
     'ArcanistPromptResponse' => 'Phobject',
     'ArcanistPromptsConfigOption' => 'ArcanistMultiSourceConfigOption',
     'ArcanistPromptsWorkflow' => 'ArcanistWorkflow',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPuppetLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPuppetLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyFlakesLinter' => 'ArcanistExternalLinter',
     'ArcanistPyFlakesLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPyLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRef' => 'ArcanistHardpointObject',
     'ArcanistRefInspector' => 'Phobject',
     'ArcanistRefView' => array(
       'Phobject',
       'ArcanistTerminalStringInterface',
     ),
     'ArcanistRemoteRef' => 'ArcanistRef',
     'ArcanistRemoteRefInspector' => 'ArcanistRefInspector',
     'ArcanistRemoteRepositoryRefsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRepositoryAPI' => 'Phobject',
     'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryLocalState' => 'Phobject',
     'ArcanistRepositoryMarkerQuery' => 'ArcanistRepositoryQuery',
     'ArcanistRepositoryQuery' => 'Phobject',
     'ArcanistRepositoryRef' => 'ArcanistRef',
     'ArcanistRepositoryRemoteQuery' => 'ArcanistRepositoryQuery',
     'ArcanistRepositoryURINormalizer' => 'Phobject',
     'ArcanistRepositoryURINormalizerTestCase' => 'PhutilTestCase',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRevisionAuthorHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionBuildableHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionCommitMessageHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionParentRevisionsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionRef' => 'ArcanistRef',
     'ArcanistRevisionRefSource' => 'Phobject',
     'ArcanistRevisionSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistRuboCopLinter' => 'ArcanistExternalLinter',
     'ArcanistRuboCopLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRubyLinter' => 'ArcanistExternalLinter',
     'ArcanistRubyLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRuntimeConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
     'ArcanistRuntimeHardpointQuery' => 'ArcanistHardpointQuery',
     'ArcanistScalarHardpoint' => 'ArcanistHardpoint',
     'ArcanistScriptAndRegexLinter' => 'ArcanistLinter',
     'ArcanistSelfClassReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSemicolonSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSetConfigWorkflow' => 'ArcanistWorkflow',
     'ArcanistSetting' => 'Phobject',
     'ArcanistSettings' => 'Phobject',
     'ArcanistShellCompleteWorkflow' => 'ArcanistWorkflow',
     'ArcanistSimpleCommitGraphQuery' => 'ArcanistCommitGraphQuery',
     'ArcanistSimpleSymbolHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistSimpleSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistSimpleSymbolRefInspector' => 'ArcanistRefInspector',
     'ArcanistSingleLintEngine' => 'ArcanistLintEngine',
     'ArcanistSingleSourceConfigOption' => 'ArcanistConfigOption',
     'ArcanistSlownessXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSlownessXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSpellingLinter' => 'ArcanistLinter',
     'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistStaticThisXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistStringConfigOption' => 'ArcanistSingleSourceConfigOption',
     'ArcanistStringListConfigOption' => 'ArcanistListConfigOption',
     'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
     'ArcanistSubversionWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistSummaryLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistSymbolEngine' => 'Phobject',
     'ArcanistSymbolRef' => 'ArcanistRef',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSystemConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistTaskRef' => 'ArcanistRef',
     'ArcanistTaskSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistTasksWorkflow' => 'ArcanistWorkflow',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTestResultParser' => 'Phobject',
     'ArcanistTestXHPASTLintSwitchHook' => 'ArcanistXHPASTLintSwitchHook',
     'ArcanistTextLinter' => 'ArcanistLinter',
     'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistThisReassignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistToStringExceptionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTodoCommentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTodoWorkflow' => 'ArcanistWorkflow',
     'ArcanistToolset' => 'Phobject',
     'ArcanistUSEnglishTranslation' => 'PhutilTranslation',
     'ArcanistUnableToParseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUndeclaredVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnitConsoleRenderer' => 'ArcanistUnitRenderer',
     'ArcanistUnitRenderer' => 'Phobject',
     'ArcanistUnitTestEngine' => 'Phobject',
     'ArcanistUnitTestResult' => 'Phobject',
     'ArcanistUnitTestResultTestCase' => 'PhutilTestCase',
     'ArcanistUnitTestableLintEngine' => 'ArcanistLintEngine',
     'ArcanistUnitWorkflow' => 'ArcanistWorkflow',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUpgradeWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistUploadWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistUsageException' => 'Exception',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUserAbortException' => 'ArcanistUsageException',
     'ArcanistUserConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistUserRef' => 'ArcanistRef',
     'ArcanistUserSymbolHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistUserSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistUserSymbolRefInspector' => 'ArcanistRefInspector',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVariableVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVectorHardpoint' => 'ArcanistHardpoint',
     'ArcanistVersionWorkflow' => 'ArcanistWorkflow',
     'ArcanistWeldWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistWhichWorkflow' => 'ArcanistWorkflow',
     'ArcanistWildConfigOption' => 'ArcanistConfigOption',
     'ArcanistWorkEngine' => 'ArcanistWorkflowEngine',
     'ArcanistWorkWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistWorkflow' => 'Phobject',
     'ArcanistWorkflowArgument' => 'Phobject',
     'ArcanistWorkflowEngine' => 'Phobject',
     'ArcanistWorkflowGitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistWorkflowInformation' => 'Phobject',
     'ArcanistWorkflowMercurialHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistWorkingCopy' => 'Phobject',
     'ArcanistWorkingCopyConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistWorkingCopyIdentity' => 'Phobject',
     'ArcanistWorkingCopyPath' => 'Phobject',
     'ArcanistWorkingCopyStateRef' => 'ArcanistRef',
     'ArcanistWorkingCopyStateRefInspector' => 'ArcanistRefInspector',
     'ArcanistXHPASTLintNamingHook' => 'Phobject',
     'ArcanistXHPASTLintNamingHookTestCase' => 'PhutilTestCase',
     'ArcanistXHPASTLintSwitchHook' => 'Phobject',
     'ArcanistXHPASTLinter' => 'ArcanistBaseXHPASTLinter',
     'ArcanistXHPASTLinterRule' => 'Phobject',
     'ArcanistXHPASTLinterRuleTestCase' => 'ArcanistLinterTestCase',
     'ArcanistXHPASTLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistXMLLinter' => 'ArcanistLinter',
     'ArcanistXMLLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistXUnitTestResultParser' => 'Phobject',
     'BaseHTTPFuture' => 'Future',
     'CSharpToolsTestEngine' => 'XUnitTestEngine',
     'CaseInsensitiveArray' => 'PhutilArray',
     'CaseInsensitiveArrayTestCase' => 'PhutilTestCase',
     'CommandException' => 'Exception',
     'ConduitClient' => 'Phobject',
     'ConduitClientException' => 'Exception',
     'ConduitClientTestCase' => 'PhutilTestCase',
     'ConduitFuture' => 'FutureProxy',
     'ConduitSearchFuture' => 'FutureAgent',
     'ExecFuture' => 'PhutilExecutableFuture',
     'ExecFutureTestCase' => 'PhutilTestCase',
     'ExecPassthruTestCase' => 'PhutilTestCase',
     'FileFinder' => 'Phobject',
     'FileFinderTestCase' => 'PhutilTestCase',
     'FileList' => 'Phobject',
     'Filesystem' => 'Phobject',
     'FilesystemException' => 'Exception',
     'FilesystemTestCase' => 'PhutilTestCase',
     'Future' => 'Phobject',
     'FutureAgent' => 'Future',
     'FutureIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'FutureIteratorTestCase' => 'PhutilTestCase',
     'FuturePool' => 'Phobject',
     'FutureProxy' => 'Future',
     'HTTPFuture' => 'BaseHTTPFuture',
     'HTTPFutureCURLResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureCertificateResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureHTTPResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureParseResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureResponseStatus' => 'Exception',
     'HTTPFutureTransportResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPSFuture' => 'BaseHTTPFuture',
     'ImmediateFuture' => 'Future',
     'LibphutilUSEnglishTranslation' => 'PhutilTranslation',
     'LinesOfALarge' => array(
       'Phobject',
       'Iterator',
     ),
     'LinesOfALargeExecFuture' => 'LinesOfALarge',
     'LinesOfALargeExecFutureTestCase' => 'PhutilTestCase',
     'LinesOfALargeFile' => 'LinesOfALarge',
     'LinesOfALargeFileTestCase' => 'PhutilTestCase',
     'MFilterTestHelper' => 'Phobject',
     'MethodCallFuture' => 'Future',
     'MethodCallFutureTestCase' => 'PhutilTestCase',
     'NoseTestEngine' => 'ArcanistUnitTestEngine',
     'PHPASTParserTestCase' => 'PhutilTestCase',
     'PhageAction' => 'Phobject',
     'PhageAgentAction' => 'PhageAction',
     'PhageAgentBootloader' => 'Phobject',
     'PhageAgentTestCase' => 'PhutilTestCase',
     'PhageExecWorkflow' => 'PhageWorkflow',
     'PhageExecuteAction' => 'PhageAction',
     'PhageLocalAction' => 'PhageAgentAction',
     'PhagePHPAgent' => 'Phobject',
     'PhagePHPAgentBootloader' => 'PhageAgentBootloader',
     'PhagePlanAction' => 'PhageAction',
     'PhageToolset' => 'ArcanistToolset',
     'PhageWorkflow' => 'ArcanistWorkflow',
     'Phobject' => 'Iterator',
     'PhobjectTestCase' => 'PhutilTestCase',
     'PhpunitTestEngine' => 'ArcanistUnitTestEngine',
     'PhpunitTestEngineTestCase' => 'PhutilTestCase',
     'PhutilAWSCloudFormationFuture' => 'PhutilAWSFuture',
     'PhutilAWSCloudWatchFuture' => 'PhutilAWSFuture',
     'PhutilAWSEC2Future' => 'PhutilAWSFuture',
     'PhutilAWSException' => 'Exception',
     'PhutilAWSFuture' => 'FutureProxy',
     'PhutilAWSManagementWorkflow' => 'PhutilArgumentWorkflow',
     'PhutilAWSS3DeleteManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
     'PhutilAWSS3Future' => 'PhutilAWSFuture',
     'PhutilAWSS3GetManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
     'PhutilAWSS3ManagementWorkflow' => 'PhutilAWSManagementWorkflow',
     'PhutilAWSS3PutManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
     'PhutilAWSv4Signature' => 'Phobject',
     'PhutilAWSv4SignatureTestCase' => 'PhutilTestCase',
     'PhutilAggregateException' => 'Exception',
     'PhutilAllCapsEnglishLocale' => 'PhutilLocale',
     'PhutilArgumentParser' => 'Phobject',
     'PhutilArgumentParserException' => 'Exception',
     'PhutilArgumentParserTestCase' => 'PhutilTestCase',
     'PhutilArgumentSpecification' => 'Phobject',
     'PhutilArgumentSpecificationException' => 'PhutilArgumentParserException',
     'PhutilArgumentSpecificationTestCase' => 'PhutilTestCase',
     'PhutilArgumentSpellingCorrector' => 'Phobject',
     'PhutilArgumentSpellingCorrectorTestCase' => 'PhutilTestCase',
     'PhutilArgumentUsageException' => 'PhutilArgumentParserException',
     'PhutilArgumentWorkflow' => 'Phobject',
     'PhutilArray' => array(
       'Phobject',
       'Countable',
       'ArrayAccess',
       'Iterator',
     ),
     'PhutilArrayCheck' => 'Phobject',
     'PhutilArrayTestCase' => 'PhutilTestCase',
     'PhutilArrayWithDefaultValue' => 'PhutilArray',
     'PhutilAsanaFuture' => 'FutureProxy',
     'PhutilBacktraceSignalHandler' => 'PhutilSignalHandler',
     'PhutilBallOfPHP' => 'Phobject',
     'PhutilBinaryAnalyzer' => 'Phobject',
     'PhutilBinaryAnalyzerTestCase' => 'PhutilTestCase',
     'PhutilBootloaderException' => 'Exception',
     'PhutilBritishEnglishLocale' => 'PhutilLocale',
     'PhutilBufferedIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilBufferedIteratorTestCase' => 'PhutilTestCase',
     'PhutilBugtraqParser' => 'Phobject',
     'PhutilBugtraqParserTestCase' => 'PhutilTestCase',
     'PhutilCIDRBlock' => 'Phobject',
     'PhutilCIDRList' => 'Phobject',
     'PhutilCallbackFilterIterator' => 'FilterIterator',
     'PhutilCallbackSignalHandler' => 'PhutilSignalHandler',
     'PhutilChannel' => 'Phobject',
     'PhutilChannelChannel' => 'PhutilChannel',
     'PhutilChannelTestCase' => 'PhutilTestCase',
     'PhutilChunkedIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilChunkedIteratorTestCase' => 'PhutilTestCase',
     'PhutilClassMapQuery' => 'Phobject',
     'PhutilCloudWatchMetric' => 'Phobject',
     'PhutilCommandString' => 'Phobject',
     'PhutilConsole' => 'Phobject',
     'PhutilConsoleBlock' => 'PhutilConsoleView',
     'PhutilConsoleError' => 'PhutilConsoleLogLine',
     'PhutilConsoleFormatter' => 'Phobject',
     'PhutilConsoleInfo' => 'PhutilConsoleLogLine',
     'PhutilConsoleList' => 'PhutilConsoleView',
     'PhutilConsoleLogLine' => 'PhutilConsoleView',
     'PhutilConsoleMessage' => 'Phobject',
     'PhutilConsoleMetrics' => 'Phobject',
     'PhutilConsoleMetricsSignalHandler' => 'PhutilSignalHandler',
     'PhutilConsoleProgressBar' => 'Phobject',
     'PhutilConsoleProgressSink' => 'PhutilProgressSink',
     'PhutilConsoleServer' => 'Phobject',
     'PhutilConsoleServerChannel' => 'PhutilChannelChannel',
     'PhutilConsoleSkip' => 'PhutilConsoleLogLine',
     'PhutilConsoleStdinNotInteractiveException' => 'Exception',
     'PhutilConsoleTable' => 'PhutilConsoleView',
     'PhutilConsoleView' => 'Phobject',
     'PhutilConsoleWarning' => 'PhutilConsoleLogLine',
     'PhutilConsoleWrapTestCase' => 'PhutilTestCase',
     'PhutilCowsay' => 'Phobject',
     'PhutilCowsayTestCase' => 'PhutilTestCase',
     'PhutilCsprintfTestCase' => 'PhutilTestCase',
     'PhutilCzechLocale' => 'PhutilLocale',
     'PhutilDOMNode' => 'Phobject',
     'PhutilDeferredLog' => 'Phobject',
     'PhutilDeferredLogTestCase' => 'PhutilTestCase',
     'PhutilDiffBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilDirectedScalarGraph' => 'AbstractDirectedGraph',
     'PhutilDirectoryFixture' => 'Phobject',
     'PhutilDocblockParser' => 'Phobject',
     'PhutilDocblockParserTestCase' => 'PhutilTestCase',
     'PhutilEditDistanceMatrix' => 'Phobject',
     'PhutilEditDistanceMatrixTestCase' => 'PhutilTestCase',
     'PhutilEditorConfig' => 'Phobject',
     'PhutilEditorConfigTestCase' => 'PhutilTestCase',
     'PhutilEmailAddress' => 'Phobject',
     'PhutilEmailAddressTestCase' => 'PhutilTestCase',
     'PhutilEmojiLocale' => 'PhutilLocale',
     'PhutilEnglishCanadaLocale' => 'PhutilLocale',
     'PhutilErrorHandler' => 'Phobject',
     'PhutilErrorHandlerTestCase' => 'PhutilTestCase',
     'PhutilErrorLog' => 'Phobject',
     'PhutilErrorTrap' => 'Phobject',
     'PhutilEvent' => 'Phobject',
     'PhutilEventConstants' => 'Phobject',
     'PhutilEventEngine' => 'Phobject',
     'PhutilEventListener' => 'Phobject',
     'PhutilEventType' => 'PhutilEventConstants',
     'PhutilExampleBufferedIterator' => 'PhutilBufferedIterator',
     'PhutilExecChannel' => 'PhutilChannel',
     'PhutilExecPassthru' => 'PhutilExecutableFuture',
     'PhutilExecutableFuture' => 'Future',
     'PhutilExecutionEnvironment' => 'Phobject',
     'PhutilFileLock' => 'PhutilLock',
     'PhutilFileLockTestCase' => 'PhutilTestCase',
     'PhutilFrenchLocale' => 'PhutilLocale',
     'PhutilGermanLocale' => 'PhutilLocale',
     'PhutilGitBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilGitHubFuture' => 'FutureProxy',
     'PhutilGitHubResponse' => 'Phobject',
     'PhutilGitURI' => 'Phobject',
     'PhutilGitURITestCase' => 'PhutilTestCase',
     'PhutilGitsprintfTestCase' => 'PhutilTestCase',
     'PhutilHTMLParser' => 'Phobject',
     'PhutilHTMLParserTestCase' => 'PhutilTestCase',
     'PhutilHTTPEngineExtension' => 'Phobject',
     'PhutilHTTPResponse' => 'Phobject',
     'PhutilHTTPResponseParser' => 'Phobject',
     'PhutilHTTPResponseParserTestCase' => 'PhutilTestCase',
     'PhutilHashingIterator' => array(
       'PhutilProxyIterator',
       'Iterator',
     ),
     'PhutilHashingIteratorTestCase' => 'PhutilTestCase',
     'PhutilHelpArgumentWorkflow' => 'PhutilArgumentWorkflow',
     'PhutilHgsprintfTestCase' => 'PhutilTestCase',
     'PhutilINIParserException' => 'Exception',
     'PhutilIPAddress' => 'Phobject',
     'PhutilIPAddressTestCase' => 'PhutilTestCase',
     'PhutilIPv4Address' => 'PhutilIPAddress',
     'PhutilIPv6Address' => 'PhutilIPAddress',
     'PhutilInteractiveEditor' => 'Phobject',
     'PhutilInvalidRuleParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilInvalidStateException' => 'Exception',
     'PhutilInvalidStateExceptionTestCase' => 'PhutilTestCase',
     'PhutilIrreducibleRuleParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilJSON' => 'Phobject',
     'PhutilJSONFragmentLexer' => 'PhutilLexer',
     'PhutilJSONParser' => 'Phobject',
     'PhutilJSONParserException' => 'Exception',
     'PhutilJSONParserTestCase' => 'PhutilTestCase',
     'PhutilJSONProtocolChannel' => 'PhutilProtocolChannel',
     'PhutilJSONProtocolChannelTestCase' => 'PhutilTestCase',
     'PhutilJSONTestCase' => 'PhutilTestCase',
     'PhutilJavaFragmentLexer' => 'PhutilLexer',
     'PhutilKoreanLocale' => 'PhutilLocale',
     'PhutilLanguageGuesser' => 'Phobject',
     'PhutilLanguageGuesserTestCase' => 'PhutilTestCase',
     'PhutilLexer' => 'Phobject',
     'PhutilLibraryConflictException' => 'Exception',
     'PhutilLibraryMapBuilder' => 'Phobject',
     'PhutilLibraryTestCase' => 'PhutilTestCase',
     'PhutilLocale' => 'Phobject',
     'PhutilLocaleTestCase' => 'PhutilTestCase',
     'PhutilLock' => 'Phobject',
     'PhutilLockException' => 'Exception',
     'PhutilLogFileChannel' => 'PhutilChannelChannel',
     'PhutilLunarPhase' => 'Phobject',
     'PhutilLunarPhaseTestCase' => 'PhutilTestCase',
     'PhutilMercurialBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilMethodNotImplementedException' => 'Exception',
     'PhutilMetricsChannel' => 'PhutilChannelChannel',
     'PhutilMissingSymbolException' => 'Exception',
     'PhutilModuleUtilsTestCase' => 'PhutilTestCase',
     'PhutilNumber' => 'Phobject',
     'PhutilOAuth1Future' => 'FutureProxy',
     'PhutilOAuth1FutureTestCase' => 'PhutilTestCase',
     'PhutilOpaqueEnvelope' => 'Phobject',
     'PhutilOpaqueEnvelopeKey' => 'Phobject',
     'PhutilOpaqueEnvelopeTestCase' => 'PhutilTestCase',
     'PhutilPHPFragmentLexer' => 'PhutilLexer',
     'PhutilPHPFragmentLexerTestCase' => 'PhutilTestCase',
     'PhutilPHPObjectProtocolChannel' => 'PhutilProtocolChannel',
     'PhutilPHPObjectProtocolChannelTestCase' => 'PhutilTestCase',
     'PhutilParserGenerator' => 'Phobject',
     'PhutilParserGeneratorException' => 'Exception',
     'PhutilParserGeneratorTestCase' => 'PhutilTestCase',
     'PhutilPayPalAPIFuture' => 'FutureProxy',
     'PhutilPersonTest' => array(
       'Phobject',
       'PhutilPerson',
     ),
     'PhutilPhtTestCase' => 'PhutilTestCase',
     'PhutilPirateEnglishLocale' => 'PhutilLocale',
     'PhutilPortugueseBrazilLocale' => 'PhutilLocale',
     'PhutilPortuguesePortugalLocale' => 'PhutilLocale',
     'PhutilPostmarkFuture' => 'FutureProxy',
     'PhutilPregsprintfTestCase' => 'PhutilTestCase',
     'PhutilProcessQuery' => 'Phobject',
     'PhutilProcessRef' => 'Phobject',
     'PhutilProcessRefTestCase' => 'PhutilTestCase',
     'PhutilProgressSink' => 'Phobject',
     'PhutilProtocolChannel' => 'PhutilChannelChannel',
     'PhutilProxyException' => 'Exception',
     'PhutilProxyIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilPygmentizeBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilPythonFragmentLexer' => 'PhutilLexer',
     'PhutilQueryStringParser' => 'Phobject',
     'PhutilQueryStringParserTestCase' => 'PhutilTestCase',
     'PhutilRawEnglishLocale' => 'PhutilLocale',
     'PhutilReadableSerializer' => 'Phobject',
     'PhutilReadableSerializerTestCase' => 'PhutilTestCase',
     'PhutilRegexException' => 'Exception',
     'PhutilRope' => 'Phobject',
     'PhutilRopeTestCase' => 'PhutilTestCase',
     'PhutilServiceProfiler' => 'Phobject',
     'PhutilShellLexer' => 'PhutilLexer',
     'PhutilShellLexerTestCase' => 'PhutilTestCase',
     'PhutilSignalHandler' => 'Phobject',
     'PhutilSignalRouter' => 'Phobject',
     'PhutilSimpleOptions' => 'Phobject',
     'PhutilSimpleOptionsLexer' => 'PhutilLexer',
     'PhutilSimpleOptionsLexerTestCase' => 'PhutilTestCase',
     'PhutilSimpleOptionsTestCase' => 'PhutilTestCase',
     'PhutilSimplifiedChineseLocale' => 'PhutilLocale',
     'PhutilSlackFuture' => 'FutureProxy',
     'PhutilSocketChannel' => 'PhutilChannel',
     'PhutilSortVector' => 'Phobject',
     'PhutilSpanishSpainLocale' => 'PhutilLocale',
     'PhutilStreamIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilSubversionBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilSystem' => 'Phobject',
     'PhutilSystemTestCase' => 'PhutilTestCase',
     'PhutilTerminalString' => 'Phobject',
     'PhutilTestCase' => 'Phobject',
     'PhutilTestCaseTestCase' => 'PhutilTestCase',
     'PhutilTestPhobject' => 'Phobject',
     'PhutilTestSkippedException' => 'Exception',
     'PhutilTestTerminatedException' => 'Exception',
     'PhutilTraditionalChineseLocale' => 'PhutilLocale',
     'PhutilTranslation' => 'Phobject',
     'PhutilTranslationTestCase' => 'PhutilTestCase',
     'PhutilTranslator' => 'Phobject',
     'PhutilTranslatorTestCase' => 'PhutilTestCase',
     'PhutilTsprintfTestCase' => 'PhutilTestCase',
     'PhutilTwitchFuture' => 'FutureProxy',
     'PhutilTypeCheckException' => 'Exception',
     'PhutilTypeExtraParametersException' => 'Exception',
     'PhutilTypeLexer' => 'PhutilLexer',
     'PhutilTypeMissingParametersException' => 'Exception',
     'PhutilTypeSpec' => 'Phobject',
     'PhutilTypeSpecTestCase' => 'PhutilTestCase',
     'PhutilURI' => 'Phobject',
     'PhutilURITestCase' => 'PhutilTestCase',
     'PhutilUSEnglishLocale' => 'PhutilLocale',
     'PhutilUTF8StringTruncator' => 'Phobject',
     'PhutilUTF8TestCase' => 'PhutilTestCase',
     'PhutilUnitTestEngine' => 'ArcanistUnitTestEngine',
     'PhutilUnitTestEngineTestCase' => 'PhutilTestCase',
     'PhutilUnknownSymbolParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilUnreachableRuleParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilUnreachableTerminalParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilUrisprintfTestCase' => 'PhutilTestCase',
     'PhutilUtilsTestCase' => 'PhutilTestCase',
     'PhutilVeryWowEnglishLocale' => 'PhutilLocale',
     'PhutilWordPressFuture' => 'FutureProxy',
     'PhutilXHPASTBinary' => 'Phobject',
+    'PlatformSymbols' => 'Phobject',
     'PytestTestEngine' => 'ArcanistUnitTestEngine',
     'TempFile' => 'Phobject',
     'TestAbstractDirectedGraph' => 'AbstractDirectedGraph',
     'XHPASTNode' => 'AASTNode',
     'XHPASTNodeTestCase' => 'PhutilTestCase',
     'XHPASTSyntaxErrorException' => 'Exception',
     'XHPASTToken' => 'AASTToken',
     'XHPASTTree' => 'AASTTree',
     'XHPASTTreeTestCase' => 'PhutilTestCase',
     'XUnitTestEngine' => 'ArcanistUnitTestEngine',
     'XUnitTestResultParserTestCase' => 'PhutilTestCase',
     'XsprintfUnknownConversionException' => 'InvalidArgumentException',
   ),
 ));
diff --git a/src/__tests__/PhutilLibraryTestCase.php b/src/__tests__/PhutilLibraryTestCase.php
index 0e5c6261..ba849a52 100644
--- a/src/__tests__/PhutilLibraryTestCase.php
+++ b/src/__tests__/PhutilLibraryTestCase.php
@@ -1,191 +1,191 @@
 <?php
 
 /**
  * @concrete-extensible
  */
 class PhutilLibraryTestCase extends PhutilTestCase {
 
   /**
    * This is more of an acceptance test case instead of a unit test. It verifies
    * that all symbols can be loaded correctly. It can catch problems like
    * missing methods in descendants of abstract base classes.
    */
   public function testEverythingImplemented() {
     id(new PhutilSymbolLoader())
       ->setLibrary($this->getLibraryName())
       ->selectAndLoadSymbols();
     $this->assertTrue(true);
   }
 
   /**
    * This is more of an acceptance test case instead of a unit test. It verifies
    * that all the library map is up-to-date.
    */
   public function testLibraryMap() {
     $root = $this->getLibraryRoot();
     $library = phutil_get_library_name_for_root($root);
 
     $new_library_map = id(new PhutilLibraryMapBuilder($root))
       ->buildMap();
 
     $bootloader = PhutilBootloader::getInstance();
     $old_library_map = $bootloader->getLibraryMapWithoutExtensions($library);
     unset($old_library_map[PhutilLibraryMapBuilder::LIBRARY_MAP_VERSION_KEY]);
 
     $identical = ($new_library_map === $old_library_map);
     if (!$identical) {
       $differences = $this->getMapDifferences(
         $old_library_map,
         $new_library_map);
       sort($differences);
     } else {
       $differences = array();
     }
 
     $this->assertTrue(
       $identical,
       pht(
         "The library map is out of date. Rebuild it with `%s`.\n".
         "These entries differ: %s.",
         'arc liberate',
         implode(', ', $differences)));
   }
 
 
   private function getMapDifferences($old, $new) {
     $changed = array();
 
     $all = $old + $new;
     foreach ($all as $key => $value) {
       $old_exists = array_key_exists($key, $old);
       $new_exists = array_key_exists($key, $new);
 
       // One map has it and the other does not, so mark it as changed.
       if ($old_exists != $new_exists) {
         $changed[] = $key;
         continue;
       }
 
       $oldv = idx($old, $key);
       $newv = idx($new, $key);
       if ($oldv === $newv) {
         continue;
       }
 
       if (is_array($oldv) && is_array($newv)) {
         $child_changed = $this->getMapDifferences($oldv, $newv);
         foreach ($child_changed as $child) {
           $changed[] = $key.'.'.$child;
         }
       } else {
         $changed[] = $key;
       }
     }
 
     return $changed;
   }
 
 
   /**
    * This is more of an acceptance test case instead of a unit test. It verifies
    * that methods in subclasses have the same visibility as the method in the
    * parent class.
    */
   public function testMethodVisibility() {
     $symbols = id(new PhutilSymbolLoader())
       ->setLibrary($this->getLibraryName())
       ->selectSymbolsWithoutLoading();
 
     $classes = array();
     foreach ($symbols as $symbol) {
       if ($symbol['type'] == 'class') {
         $classes[$symbol['name']] = new ReflectionClass($symbol['name']);
       }
     }
 
     $failures = array();
 
     foreach ($classes as $class_name => $class) {
       $parents = array();
       $parent = $class;
       while ($parent = $parent->getParentClass()) {
         $parents[] = $parent;
       }
 
       $interfaces = $class->getInterfaces();
 
       foreach ($class->getMethods() as $method) {
         $method_name = $method->getName();
 
         foreach (array_merge($parents, $interfaces) as $extends) {
           if ($extends->hasMethod($method_name)) {
             $xmethod = $extends->getMethod($method_name);
 
             if (!$this->compareVisibility($xmethod, $method)) {
               $failures[] = pht(
                 'Class "%s" implements method "%s" with the wrong visibility. '.
                 'The method has visibility "%s", but it is defined in parent '.
-                '"%s" with visibility "%s". In Phabricator, a method which '.
-                'overrides another must always have the same visibility.',
+                '"%s" with visibility "%s". A method which overrides another '.
+                'must always have the same visibility.',
                 $class_name,
                 $method_name,
                 $this->getVisibility($method),
                 $extends->getName(),
                 $this->getVisibility($xmethod));
             }
 
             // We found a declaration somewhere, so stop looking.
             break;
           }
         }
       }
     }
 
     $this->assertTrue(
       empty($failures),
       "\n\n".implode("\n\n", $failures));
   }
 
   /**
    * Get the name of the library currently being tested.
    */
   protected function getLibraryName() {
     return phutil_get_library_name_for_root($this->getLibraryRoot());
   }
 
   /**
    * Get the root directory for the library currently being tested.
    */
   protected function getLibraryRoot() {
     $caller = id(new ReflectionClass($this))->getFileName();
     return phutil_get_library_root_for_path($caller);
   }
 
   private function compareVisibility(
     ReflectionMethod $parent_method,
     ReflectionMethod $method) {
 
     static $bitmask;
 
     if ($bitmask === null) {
       $bitmask  = ReflectionMethod::IS_PUBLIC;
       $bitmask += ReflectionMethod::IS_PROTECTED;
       $bitmask += ReflectionMethod::IS_PRIVATE;
     }
 
     $parent_modifiers = $parent_method->getModifiers();
     $modifiers = $method->getModifiers();
     return !(($parent_modifiers ^ $modifiers) & $bitmask);
   }
 
   private function getVisibility(ReflectionMethod $method) {
     if ($method->isPrivate()) {
       return 'private';
     } else if ($method->isProtected()) {
       return 'protected';
     } else {
       return 'public';
     }
   }
 
 }
diff --git a/src/conduit/ArcanistConduitEngine.php b/src/conduit/ArcanistConduitEngine.php
index cd2b411e..8e7a1de4 100644
--- a/src/conduit/ArcanistConduitEngine.php
+++ b/src/conduit/ArcanistConduitEngine.php
@@ -1,107 +1,107 @@
 <?php
 
 final class ArcanistConduitEngine
   extends Phobject {
 
   private $conduitURI;
   private $conduitToken;
   private $conduitTimeout;
   private $client;
 
   public function isCallable() {
     return ($this->conduitURI !== null);
   }
 
   public function setConduitURI($conduit_uri) {
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   public function getConduitURI() {
     return $this->conduitURI;
   }
 
   public function setConduitToken($conduit_token) {
     $this->conduitToken = $conduit_token;
     return $this;
   }
 
   public function getConduitToken() {
     return $this->conduitToken;
   }
 
   public function setConduitTimeout($conduit_timeout) {
     $this->conduitTimeout = $conduit_timeout;
     return $this;
   }
 
   public function getConduitTimeout() {
     return $this->conduitTimeout;
   }
 
   public function newFuture($method, array $parameters) {
     if ($this->conduitURI == null && $this->client === null) {
       $this->raiseURIException();
     }
 
     $future = $this->getClient()->callMethod($method, $parameters);
 
     $call_future = id(new ArcanistConduitCallFuture($future))
       ->setEngine($this);
 
     return $call_future;
   }
 
   private function getClient() {
     if (!$this->client) {
       $conduit_uri = $this->getConduitURI();
 
       $client = new ConduitClient($conduit_uri);
 
       $timeout = $this->getConduitTimeout();
       if ($timeout) {
         $client->setTimeout($timeout);
       }
 
       $token = $this->getConduitToken();
       if ($token) {
         $client->setConduitToken($this->getConduitToken());
       }
 
       $this->client = $client;
     }
 
     return $this->client;
   }
 
   private function raiseURIException() {
     $list = id(new PhutilConsoleList())
       ->addItem(
         pht(
           'Run in a working copy with "phabricator.uri" set in ".arcconfig".'))
       ->addItem(
         pht(
           'Set a default URI with `arc set-config phabricator.uri <uri>`.'))
       ->addItem(
         pht(
           'Specify a URI explicitly with `--config phabricator.uri=<uri>`.'));
 
     $block = id(new PhutilConsoleBlock())
       ->addParagraph(
         pht(
-          'This command needs to communicate with Phabricator, but no '.
-          'Phabricator URI is configured.'))
+          'This command needs to communicate with a server, but no '.
+          'server URI is configured.'))
       ->addList($list);
 
     throw new ArcanistUsageException($block->drawConsoleString());
   }
 
   public static function newConduitEngineFromConduitClient(
     ConduitClient $client) {
 
     $engine = new self();
     $engine->client = $client;
 
     return $engine;
   }
 }
diff --git a/src/config/arc/ArcanistArcConfigurationEngineExtension.php b/src/config/arc/ArcanistArcConfigurationEngineExtension.php
index d40159d5..3fdff3ff 100644
--- a/src/config/arc/ArcanistArcConfigurationEngineExtension.php
+++ b/src/config/arc/ArcanistArcConfigurationEngineExtension.php
@@ -1,164 +1,165 @@
 <?php
 
 final class ArcanistArcConfigurationEngineExtension
   extends ArcanistConfigurationEngineExtension {
 
   const EXTENSIONKEY = 'arc';
 
   const KEY_ALIASES = 'aliases';
   const KEY_PROMPTS = 'prompts';
 
   public function newConfigurationOptions() {
     // TOOLSETS: Restore "load", and maybe this other stuff.
 
 /*
       'load' => array(
         'type' => 'list',
         'legacy' => 'phutil_libraries',
         'help' => pht(
           '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.'),
         'default' => array(),
         'example' => '["/var/arc/customlib/src"]',
       ),
       'editor' => array(
         'type' => 'string',
         'help' => pht(
           'Command to use to invoke an interactive editor, like `%s` or `%s`. '.
           'This setting overrides the %s environmental variable.',
           'nano',
           'vim',
           'EDITOR'),
         'example' => '"nano"',
       ),
       'https.cabundle' => array(
         'type' => 'string',
         'help' => pht(
           "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',
       ),
       'browser' => array(
         'type' => 'string',
         'help' => pht('Command to use to invoke a web browser.'),
         'example' => '"gnome-www-browser"',
       ),
 */
 
 
 
     return array(
       id(new ArcanistStringConfigOption())
         ->setKey('base')
         ->setSummary(pht('Ruleset for selecting commit ranges.'))
         ->setHelp(
           pht(
             'Base commit ruleset to invoke when determining the start of a '.
             'commit range. See "Arcanist User Guide: Commit Ranges" for '.
             'details.'))
         ->setExamples(
           array(
             'arc:amended, arc:prompt',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('repository')
         ->setAliases(
           array(
             'repository.callsign',
           ))
         ->setSummary(pht('Repository for the current working copy.'))
         ->setHelp(
           pht(
-            'Associate the working copy with a specific Phabricator '.
-            'repository. Normally, Arcanist 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.'))
+            'Associate the working copy with a specific repository. Normally, '.
+            'this association can be determined automatically, but if your '.
+            'setup is unusual you can use this option to tell it what the '.
+            'desired value is.'))
         ->setExamples(
           array(
             'libexample',
             'XYZ',
             'R123',
             '123',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('phabricator.uri')
         ->setAliases(
           array(
             'conduit_uri',
             'default',
           ))
-        ->setSummary(pht('Phabricator install to connect to.'))
+        ->setSummary(pht('Server to connect to.'))
         ->setHelp(
           pht(
             'Associates this working copy with a specific installation of '.
-            'Phabricator.'))
+            '%s (or compatible software).',
+            PlatformSymbols::getPlatformServerName()))
         ->setExamples(
           array(
-            'https://phabricator.mycompany.com/',
+            'https://devtools.example.com/',
           )),
       id(new ArcanistAliasesConfigOption())
         ->setKey(self::KEY_ALIASES)
         ->setDefaultValue(array())
         ->setSummary(pht('List of command aliases.'))
         ->setHelp(
           pht(
             'Configured command aliases. Use the "alias" workflow to define '.
             'aliases.')),
       id(new ArcanistPromptsConfigOption())
         ->setKey(self::KEY_PROMPTS)
         ->setDefaultValue(array())
         ->setSummary(pht('List of prompt responses.'))
         ->setHelp(
           pht(
             'Configured prompt aliases. Use the "prompts" workflow to '.
             'show prompts and responses.')),
       id(new ArcanistStringListConfigOption())
         ->setKey('arc.land.onto')
         ->setDefaultValue(array())
         ->setSummary(pht('Default list of "onto" refs for "arc land".'))
         ->setHelp(
           pht(
             'Specifies the default behavior when "arc land" is run with '.
             'no "--onto" flag.'))
         ->setExamples(
           array(
             '["master"]',
           )),
       id(new ArcanistStringListConfigOption())
         ->setKey('pager')
         ->setDefaultValue(array())
         ->setSummary(pht('Default pager command.'))
         ->setHelp(
           pht(
             'Specify the pager command to use when displaying '.
             'documentation.'))
         ->setExamples(
           array(
             '["less", "-R", "--"]',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('arc.land.onto-remote')
         ->setSummary(pht('Default list of "onto" remote for "arc land".'))
         ->setHelp(
           pht(
             'Specifies the default behavior when "arc land" is run with '.
             'no "--onto-remote" flag.'))
         ->setExamples(
           array(
             'origin',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('arc.land.strategy')
         ->setSummary(
           pht(
             'Configure a default merge strategy for "arc land".'))
         ->setHelp(
           pht(
             'Specifies the default behavior when "arc land" is run with '.
             'no "--strategy" flag.')),
     );
   }
 
 }
diff --git a/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php b/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
index 098d04a2..fd381969 100644
--- a/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
+++ b/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
@@ -1,27 +1,27 @@
 <?php
 
 final class ArcanistBlindlyTrustHTTPEngineExtension
   extends PhutilHTTPEngineExtension {
 
   const EXTENSIONKEY = 'arc.https.blind';
 
   private $domains = array();
 
   public function setDomains(array $domains) {
     foreach ($domains as $domain) {
       $this->domains[phutil_utf8_strtolower($domain)] = true;
     }
     return $this;
   }
 
   public function getExtensionName() {
-    return pht('Arcanist HTTPS Trusted Domains');
+    return pht('HTTPS Trusted Domains');
   }
 
   public function shouldTrustAnySSLAuthorityForURI(PhutilURI $uri) {
     $domain = $uri->getDomain();
     $domain = phutil_utf8_strtolower($domain);
     return isset($this->domains[$domain]);
   }
 
 }
diff --git a/src/configuration/ArcanistSettings.php b/src/configuration/ArcanistSettings.php
index 67081703..8f67bf7e 100644
--- a/src/configuration/ArcanistSettings.php
+++ b/src/configuration/ArcanistSettings.php
@@ -1,315 +1,314 @@
 <?php
 
 final class ArcanistSettings extends Phobject {
 
   private function getOptions() {
     $legacy_builtins = array(
       'default' => array(
         'type' => 'string',
         'help' => pht(
-          'The URI of a Phabricator install to connect to by default, if '.
-          '%s is run in a project without a Phabricator URI or run outside '.
+          'The URI of a server to connect to by default, if '.
+          '%s is run in a project without a configured URI or run outside '.
           'of a project.',
           'arc'),
-        'example' => '"http://phabricator.example.com/"',
+        'example' => '"http://devtools.example.com/"',
       ),
       'base' => array(
         'type' => 'string',
         'help' => pht(
           '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' => pht(
           '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.'),
         'default' => array(),
         'example' => '["/var/arc/customlib/src"]',
       ),
       'repository.callsign' => array(
         'type' => 'string',
         'example' => '"X"',
         'help' => pht(
-          'Associate the working copy with a specific Phabricator repository. '.
+          'Associate the working copy with a specific repository. '.
           'Normally, %s 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.',
           'arc'),
       ),
       'phabricator.uri' => array(
         'type' => 'string',
         'legacy' => 'conduit_uri',
-        'example' => '"https://phabricator.mycompany.com/"',
+        'example' => '"https://devtools.example.com/"',
         'help' => pht(
-          'Associates this working copy with a specific installation of '.
-          'Phabricator.'),
+          'Associates this working copy with a specific server.'),
       ),
       'lint.engine' => array(
         'type' => 'string',
         'legacy' => 'lint_engine',
         'help' => pht(
           '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' => pht(
           'The name of a default unit test engine to use, if no unit test '.
           'engine is specified by the current project.'),
         'example' => '"ExampleUnitTestEngine"',
       ),
       'arc.land.onto.default' => array(
         'type' => 'string',
         'help' => pht(
           'The name of the default branch to land changes onto when '.
           '`%s` is run.',
           'arc land'),
         'example' => '"develop"',
       ),
       'history.immutable' => array(
         'type' => 'bool',
         'legacy' => 'immutable_history',
         'help' => pht(
           'If true, %s 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.',
           'arc'),
         'example' => 'false',
       ),
       'editor' => array(
         'type' => 'string',
         'help' => pht(
           'Command to use to invoke an interactive editor, like `%s` or `%s`. '.
           'This setting overrides the %s environmental variable.',
           'nano',
           'vim',
           'EDITOR'),
         'example' => '"nano"',
       ),
       'https.cabundle' => array(
         'type' => 'string',
         'help' => pht(
-          "Path to a custom CA bundle file to be used for arcanist's cURL ".
-          "calls. This is used primarily when your conduit endpoint is ".
+          "Path to a custom CA bundle file to be used for cURL calls. ".
+          "This is used primarily when your conduit endpoint is ".
           "behind HTTPS signed by your organization's internal CA."),
         'example' => 'support/yourca.pem',
       ),
       'browser' => array(
         'type' => 'string',
         'help' => pht('Command to use to invoke a web browser.'),
         'example' => '"gnome-www-browser"',
       ),
       'events.listeners' => array(
         'type' => 'list',
         'help' => pht('List of event listener classes to install at startup.'),
         'default' => array(),
         'example' => '["ExampleEventListener"]',
       ),
       'arc.autostash' => array(
         'type' => 'bool',
         'help' => pht(
           'Whether %s should permit the automatic stashing of changes in 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 '.
+          'working directory from the local stash if an operation '.
           'causes an unrecoverable error.',
           'arc'),
         'default' => false,
         'example' => 'false',
       ),
       'aliases' => array(
         'type' => 'aliases',
         'help' => pht(
           'Configured command aliases. Use "arc alias" to define aliases.'),
       ),
     );
 
     $settings = ArcanistSetting::getAllSettings();
     foreach ($settings as $key => $setting) {
       $settings[$key] = $setting->getLegacyDictionary();
     }
 
     $results = $settings + $legacy_builtins;
     ksort($results);
 
     return $results;
   }
 
   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(
             pht(
               "Type of setting '%s' must be boolean, like 'true' or 'false'.",
               $key));
         }
         break;
       case 'list':
         if (is_array($value)) {
           break;
         }
 
         if (is_string($value)) {
           $list = json_decode($value, true);
           if (is_array($list)) {
             $value = $list;
             break;
           }
         }
 
         throw new ArcanistUsageException(
           pht(
             "Type of setting '%s' must be list. You can specify a list ".
             "in JSON, like: %s",
             $key,
             '["apple", "banana", "cherry"]'));
 
       case 'string':
         if (!is_scalar($value)) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be string.",
               $key));
         }
         $value = (string)$value;
         break;
       case 'wild':
         break;
       case 'aliases':
         throw new Exception(
           pht(
             'Use "arc alias" to configure aliases, not "arc set-config".'));
         break;
 
     }
 
     return $value;
   }
 
   public function willReadValue($key, $value) {
     $type = $this->getType($key);
     switch ($type) {
       case 'string':
         if (!is_string($value)) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be string.",
               $key));
         }
         break;
       case 'bool':
         if ($value !== true && $value !== false) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be boolean.",
               $key));
         }
         break;
       case 'list':
         if (!is_array($value)) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be list.",
               $key));
         }
         break;
       case 'wild':
       case 'aliases':
         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/console/PhutilConsoleFormatter.php b/src/console/PhutilConsoleFormatter.php
index d380c961..43f1fadc 100644
--- a/src/console/PhutilConsoleFormatter.php
+++ b/src/console/PhutilConsoleFormatter.php
@@ -1,98 +1,113 @@
 <?php
 
 final class PhutilConsoleFormatter extends Phobject {
 
   private static $colorCodes = array(
     'black'   => 0,
     'red'     => 1,
     'green'   => 2,
     'yellow'  => 3,
     'blue'    => 4,
     'magenta' => 5,
     'cyan'    => 6,
     'white'   => 7,
     'default' => 9,
   );
 
   private static $disableANSI;
 
   public static function disableANSI($disable) {
     self::$disableANSI = $disable;
   }
 
   public static function getDisableANSI() {
     if (self::$disableANSI === null) {
-      $term = phutil_utf8_strtolower(getenv('TERM'));
-      // ansicon enables ANSI support on Windows
-      if (!$term && getenv('ANSICON')) {
-        $term = 'ansi';
+      self::$disableANSI = self::newShouldDisableAnsi();
+    }
+    return self::$disableANSI;
+  }
+
+  private static function newShouldDisableANSI() {
+    $term = phutil_utf8_strtolower(getenv('TERM'));
+
+    // ansicon enables ANSI support on Windows
+    if (!$term && getenv('ANSICON')) {
+      $term = 'ansi';
+    }
+
+
+    if (phutil_is_windows()) {
+      if ($term !== 'cygwin' && $term !== 'ansi') {
+        return true;
       }
+    }
+
+    $stdout = PhutilSystem::getStdoutHandle();
+    if ($stdout === null) {
+      return true;
+    }
 
-      if (phutil_is_windows() && $term !== 'cygwin' && $term !== 'ansi') {
-        self::$disableANSI = true;
-      } else if (!defined('STDOUT')) {
-        self::$disableANSI = true;
-      } else if (function_exists('posix_isatty') && !posix_isatty(STDOUT)) {
-        self::$disableANSI = true;
-      } else {
-        self::$disableANSI = false;
+    if (function_exists('posix_isatty')) {
+      if (!posix_isatty($stdout)) {
+        return true;
       }
     }
-    return self::$disableANSI;
+
+    return false;
   }
 
   public static function formatString($format /* ... */) {
     $args = func_get_args();
     $args[0] = self::interpretFormat($args[0]);
     return call_user_func_array('sprintf', $args);
   }
 
   public static function replaceColorCode($matches) {
     $codes = self::$colorCodes;
     $offset = 30 + $codes[$matches[2]];
     $default = 39;
     if ($matches[1] == 'bg') {
       $offset += 10;
       $default += 10;
     }
 
     return chr(27).'['.$offset.'m'.$matches[3].chr(27).'['.$default.'m';
   }
 
   public static function interpretFormat($format) {
     $colors = implode('|', array_keys(self::$colorCodes));
 
     // Sequence should be preceded by start-of-string or non-backslash
     // escaping.
     $bold_re      = '/(?<![\\\\])\*\*(.*)\*\*/sU';
     $underline_re = '/(?<![\\\\])__(.*)__/sU';
     $invert_re    = '/(?<![\\\\])##(.*)##/sU';
 
     if (self::getDisableANSI()) {
       $format = preg_replace($bold_re,      '\1',   $format);
       $format = preg_replace($underline_re, '\1',   $format);
       $format = preg_replace($invert_re,    '\1',   $format);
       $format = preg_replace(
         '@<(fg|bg):('.$colors.')>(.*)</\1>@sU',
         '\3',
         $format);
     } else {
       $esc        = chr(27);
       $bold       = $esc.'[1m'.'\\1'.$esc.'[m';
       $underline  = $esc.'[4m'.'\\1'.$esc.'[m';
       $invert     = $esc.'[7m'.'\\1'.$esc.'[m';
 
       $format = preg_replace($bold_re,      $bold,      $format);
       $format = preg_replace($underline_re, $underline, $format);
       $format = preg_replace($invert_re,    $invert,    $format);
       $format = preg_replace_callback(
         '@<(fg|bg):('.$colors.')>(.*)</\1>@sU',
         array(__CLASS__, 'replaceColorCode'),
         $format);
     }
 
     // Remove backslash escaping
     return preg_replace('/\\\\(\*\*.*\*\*|__.*__|##.*##)/sU', '\1', $format);
   }
 
 }
diff --git a/src/differential/ArcanistDifferentialCommitMessage.php b/src/differential/ArcanistDifferentialCommitMessage.php
index 912ee4be..cada4895 100644
--- a/src/differential/ArcanistDifferentialCommitMessage.php
+++ b/src/differential/ArcanistDifferentialCommitMessage.php
@@ -1,149 +1,149 @@
 <?php
 
 /**
  * Represents a parsed commit message.
  */
 final class ArcanistDifferentialCommitMessage extends Phobject {
 
   private $rawCorpus;
   private $revisionID;
   private $fields = array();
   private $xactions = null;
 
   private $gitSVNBaseRevision;
   private $gitSVNBasePath;
   private $gitSVNUUID;
 
   public static function newFromRawCorpus($corpus) {
     $obj = new ArcanistDifferentialCommitMessage();
     $obj->rawCorpus = $corpus;
     $obj->revisionID = $obj->parseRevisionIDFromRawCorpus($corpus);
 
     $pattern = '/^git-svn-id:\s*([^@]+)@(\d+)\s+(.*)$/m';
     $match = null;
     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 getRevisionMonogram() {
     if ($this->revisionID) {
       return 'D'.$this->revisionID;
     }
     return null;
   }
 
   public function pullDataFromConduit(
     ConduitClient $conduit,
     $partial = false) {
 
     $result = $conduit->callMethodSynchronous(
       'differential.parsecommitmessage',
       array(
         'corpus'  => $this->rawCorpus,
         'partial' => $partial,
       ));
 
     $this->fields = $result['fields'];
 
     // NOTE: This does not exist prior to late October 2017.
     $this->xactions = idx($result, 'transactions');
 
     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);
   }
 
   public function getTransactions() {
     return $this->xactions;
   }
 
   /**
    * Extract the revision ID from a commit message.
    *
    * @param string Raw commit message.
    * @return int|null Revision ID, if the commit message contains one.
    */
   private function parseRevisionIDFromRawCorpus($corpus) {
     $match = null;
     if (!preg_match('/^Differential Revision:\s*(.+)/im', $corpus, $match)) {
       return null;
     }
 
     $revision_value = trim($match[1]);
     $revision_pattern = '/^[dD]([1-9]\d*)\z/';
 
     // Accept a bare revision ID like "D123".
     if (preg_match($revision_pattern, $revision_value, $match)) {
       return (int)$match[1];
     }
 
     // Otherwise, try to find a full URI.
     $uri = new PhutilURI($revision_value);
     $path = $uri->getPath();
     $path = trim($path, '/');
     if (preg_match($revision_pattern, $path, $match)) {
       return (int)$match[1];
     }
 
     throw new ArcanistUsageException(
       pht(
         'Invalid "Differential Revision" field in commit message. This field '.
-        'should have a revision identifier like "%s" or a Phabricator URI '.
+        'should have a revision identifier like "%s" or a server URI '.
         'like "%s", but has "%s".',
         'D123',
-        'https://phabricator.example.com/D123',
+        'https://devtools.example.com/D123',
         $revision_value));
   }
 
 }
diff --git a/src/filesystem/PhutilErrorLog.php b/src/filesystem/PhutilErrorLog.php
index bc316c9e..d652d854 100644
--- a/src/filesystem/PhutilErrorLog.php
+++ b/src/filesystem/PhutilErrorLog.php
@@ -1,101 +1,101 @@
 <?php
 
 
 final class PhutilErrorLog
   extends Phobject {
 
   private $logName;
   private $logPath;
 
   public function setLogName($log_name) {
     $this->logName = $log_name;
     return $this;
   }
 
   public function getLogName() {
     return $this->logName;
   }
 
   public function setLogPath($log_path) {
     $this->logPath = $log_path;
     return $this;
   }
 
   public function getLogPath() {
     return $this->logPath;
   }
 
   public function activateLog() {
     $log_path = $this->getLogPath();
 
     if ($log_path !== null && false) {
       // Test that the path is writable.
       $write_exception = null;
       try {
         Filesystem::assertWritableFile($log_path);
       } catch (FilesystemException $ex) {
         $write_exception = $ex;
       }
 
       // If we hit an exception, try to create the containing directory.
       if ($write_exception) {
         $log_dir = dirname($log_path);
         if (!Filesystem::pathExists($log_dir)) {
           try {
             Filesystem::createDirectory($log_dir, 0755, true);
           } catch (FilesystemException $ex) {
             throw new PhutilProxyException(
               pht(
                 'Unable to write log "%s" to path "%s". The containing '.
                 'directory ("%s") does not exist or is not readable, and '.
                 'could not be created.',
                 $this->getLogName(),
                 $log_path,
                 $log_dir),
               $ex);
           }
         }
 
         // If we created the parent directory, test if the path is writable
         // again.
         try {
           Filesystem::assertWritableFile($log_path);
           $write_exception = null;
         } catch (FilesystemException $ex) {
           $write_exception = $ex;
         }
       }
 
       // If we ran into a write exception and couldn't resolve it, fail.
       if ($write_exception) {
         throw new PhutilProxyException(
           pht(
             'Unable to write log "%s" to path "%s" because the path is not '.
             'writable.',
             $this->getLogName(),
             $log_path),
           $write_exception);
       }
     }
 
     ini_set('error_log', $log_path);
     PhutilErrorHandler::setErrorListener(array($this, 'onError'));
   }
 
   public function onError($event, $value, array $metadata) {
     // If we've set "error_log" to a real file, so messages won't be output to
     // stderr by default. Copy them to stderr.
 
     if ($this->logPath === null) {
       return;
     }
 
     $message = idx($metadata, 'default_message');
 
     if (strlen($message)) {
       $message = tsprintf("%B\n", $message);
-      @fwrite(STDERR, $message);
+      PhutilSystem::writeStderr($message);
     }
   }
 
 }
diff --git a/src/future/exec/PhutilExecPassthru.php b/src/future/exec/PhutilExecPassthru.php
index fc61dc21..63921cf0 100644
--- a/src/future/exec/PhutilExecPassthru.php
+++ b/src/future/exec/PhutilExecPassthru.php
@@ -1,156 +1,160 @@
 <?php
 
 /**
  * Execute a command which takes over stdin, stdout and stderr, similar to
  * `passthru()`, but which preserves TTY semantics, escapes arguments, and is
  * traceable.
  *
  * Passthru commands use the `STDIN`, `STDOUT` and `STDERR` of the parent
  * process, so input can be read from the console and output is printed to it.
  * This is primarily useful for executing things like `$EDITOR` from command
  * line scripts.
  *
  *   $exec = new PhutilExecPassthru('nano -- %s', $filename);
  *   $err = $exec->resolve();
  *
  * You can set the current working directory for the command with
  * @{method:setCWD}, and set the environment with @{method:setEnv}.
  *
  * @task command  Executing Passthru Commands
  */
 final class PhutilExecPassthru extends PhutilExecutableFuture {
 
   private $stdinData;
 
   public function write($data) {
     $this->stdinData = $data;
     return $this;
   }
 
 /* -(  Executing Passthru Commands  )---------------------------------------- */
 
 
   public function execute() {
     phlog(
       pht(
         'The "execute()" method of "PhutilExecPassthru" is deprecated and '.
         'calls should be replaced with "resolve()". See T13660.'));
     return $this->resolve();
   }
 
   /**
    * Execute this command.
    *
    * @return int  Error code returned by the subprocess.
    *
    * @task command
    */
   private function executeCommand() {
     $command = $this->getCommand();
 
     $is_write = ($this->stdinData !== null);
 
     if ($is_write) {
       $stdin_spec = array('pipe', 'r');
     } else {
-      $stdin_spec = STDIN;
+      $stdin_spec = PhutilSystem::getStdinHandle();
     }
 
-    $spec = array($stdin_spec, STDOUT, STDERR);
+    $spec = array(
+      $stdin_spec,
+      PhutilSystem::getStdoutHandle(),
+      PhutilSystem::getStderrHandle(),
+    );
     $pipes = array();
 
     $unmasked_command = $command->getUnmaskedString();
 
     if ($this->hasEnv()) {
       $env = $this->getEnv();
     } else {
       $env = null;
     }
 
     $cwd = $this->getCWD();
 
     $options = array();
     if (phutil_is_windows()) {
       // Without 'bypass_shell', things like launching vim don't work properly,
       // and we can't execute commands with spaces in them, and all commands
       // invoked from git bash fail horridly, and everything is a mess in
       // general.
       $options['bypass_shell'] = true;
     }
 
     $trap = new PhutilErrorTrap();
       $proc = @proc_open(
         $unmasked_command,
         $spec,
         $pipes,
         $cwd,
         $env,
         $options);
       $errors = $trap->getErrorsAsString();
     $trap->destroy();
 
     if (!is_resource($proc)) {
       // See T13504. When "proc_open()" is given a command with a binary
       // that isn't available on Windows with "bypass_shell", the function
       // fails entirely.
       if (phutil_is_windows()) {
         $err = 1;
       } else {
         throw new Exception(
           pht(
             'Failed to passthru %s: %s',
             'proc_open()',
             $errors));
       }
     } else {
       if ($is_write) {
         fwrite($pipes[0], $this->stdinData);
         fclose($pipes[0]);
       }
 
       $err = proc_close($proc);
     }
 
     return $err;
   }
 
 
 /* -(  Future  )------------------------------------------------------------- */
 
 
   public function isReady() {
     // This isn't really a future because it executes synchronously and has
     // full control of the console. We're just implementing the interfaces to
     // make it easier to share code with ExecFuture.
 
     if (!$this->hasResult()) {
       $result = $this->executeCommand();
       $this->setResult($result);
     }
 
     return true;
   }
 
 
 
   protected function getServiceProfilerStartParameters() {
     return array(
       'type' => 'exec',
       'subtype' => 'passthru',
       'command' => phutil_string_cast($this->getCommand()),
     );
   }
 
   protected function getServiceProfilerResultParameters() {
     if ($this->hasResult()) {
       $err = $this->getResult();
     } else {
       $err = null;
     }
 
     return array(
       'err' => $err,
     );
   }
 
 }
diff --git a/src/internationalization/pht.php b/src/internationalization/pht.php
index 5a075a57..1d9a2f7b 100644
--- a/src/internationalization/pht.php
+++ b/src/internationalization/pht.php
@@ -1,46 +1,50 @@
 <?php
 
 /**
  * Translate a string. It uses a translator set by
  * `PhutilTranslator::setInstance()` or translations specified by
  * `PhutilTranslator::getInstance()->setTranslations()` and language rules set
  * by `PhutilTranslator::getInstance()->setLocale()`.
  *
  * @param string Translation identifier with `sprintf()` placeholders.
  * @param mixed Value to select the variant from (e.g. singular or plural).
  * @param ... Next values referenced from $text.
  * @return string Translated string with substituted values.
  */
 function pht($text, $variant = null /* , ... */) {
   $args = func_get_args();
   $translator = PhutilTranslator::getInstance();
   return call_user_func_array(array($translator, 'translate'), $args);
 }
 
 /**
  * Count all elements in an array, or something in an object.
  *
  * @param  array|Countable  A countable object.
  * @return PhutilNumber     Returns the number of elements in the input
  *                          parameter.
  */
 function phutil_count($countable) {
   if (!(is_array($countable) || $countable instanceof Countable)) {
     throw new InvalidArgumentException(pht('Argument should be countable.'));
   }
 
   return new PhutilNumber(count($countable));
 }
 
 /**
  * Provide a gendered argument to the translation engine.
  *
  * This function does nothing and only serves as a marker for the static
  * extractor so it knows particular arguments may vary on gender.
  *
  * @param PhutilPerson Something implementing @{interface:PhutilPerson}.
  * @return PhutilPerson The argument, unmodified.
  */
 function phutil_person(PhutilPerson $person) {
   return $person;
 }
+
+function pht_list(array $items) {
+  return implode(', ', $items);
+}
diff --git a/src/lint/linter/ArcanistCSharpLinter.php b/src/lint/linter/ArcanistCSharpLinter.php
index 6120a07b..e2b00b5a 100644
--- a/src/lint/linter/ArcanistCSharpLinter.php
+++ b/src/lint/linter/ArcanistCSharpLinter.php
@@ -1,261 +1,261 @@
 <?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);
   }
 
   protected 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(
           pht(
             "In order to keep StyleCop integration with IDEs and other tools ".
-            "consistent with Arcanist results, you aren't permitted to ".
+            "consistent with lint results, you aren't permitted to ".
             "disable StyleCop rules within '%s'. Instead configure the ".
             "severity using the StyleCop settings dialog (usually accessible ".
             "from within your IDE). StyleCop settings for your project will ".
-            "be used when linting for Arcanist.",
+            "be used when linting.",
             '.arclint'));
       }
     }
     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
    * 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(
         pht('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(pht('Unable to locate %s.', '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(
         pht(
           'You are running an old version of %s. Please '.
           'upgrade to version %s.',
           'cslint',
           self::SUPPORTED_VERSION));
     }
     $ver = (int)$stdout;
     if ($ver < self::SUPPORTED_VERSION) {
       throw new Exception(
         pht(
           'You are running an old version of %s. Please '.
           'upgrade to version %s.',
           'cslint',
           self::SUPPORTED_VERSION));
     } else if ($ver > self::SUPPORTED_VERSION) {
       throw new Exception(
         pht(
-          'Arcanist does not support this version of %s (it is newer). '.
-          'You can try upgrading Arcanist with `%s`.',
+          'This version of %s is not supported (it is too new). '.
+          'You can try upgrading with `%s`.',
           'cslint',
           '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
         // 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
         // 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 didLintPaths(array $paths) {
     if ($this->futures) {
       $futures = id(new FutureIterator($this->futures))
         ->limit(8);
       foreach ($futures as $future) {
         $this->resolveFuture($future);
       }
       $this->futures = array();
     }
   }
 
   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/ArcanistPhutilLibraryLinter.php b/src/lint/linter/ArcanistPhutilLibraryLinter.php
index 3cef927b..955e2073 100644
--- a/src/lint/linter/ArcanistPhutilLibraryLinter.php
+++ b/src/lint/linter/ArcanistPhutilLibraryLinter.php
@@ -1,370 +1,372 @@
 <?php
 
 /**
  * Applies lint rules for Phutil libraries. We enforce three rules:
  *
  *   # If you use a symbol, it must be defined somewhere.
  *   # If you define a symbol, it must not duplicate another definition.
  *   # If you define a class or interface in a file, it MUST be the only symbol
  *     defined in that file.
  */
 final class ArcanistPhutilLibraryLinter extends ArcanistLinter {
 
   const LINT_UNKNOWN_SYMBOL      = 1;
   const LINT_DUPLICATE_SYMBOL    = 2;
   const LINT_ONE_CLASS_PER_FILE  = 3;
   const LINT_NONCANONICAL_SYMBOL = 4;
 
   public function getInfoName() {
     return pht('Phutil Library Linter');
   }
 
   public function getInfoDescription() {
     return pht(
       'Make sure all the symbols used in a %s library are defined and known. '.
       'This linter is specific to PHP source in %s libraries.',
       'libphutil',
       'libphutil');
   }
 
   public function getLinterName() {
     return 'PHL';
   }
 
   public function getLinterConfigurationName() {
     return 'phutil-library';
   }
 
   public function getCacheGranularity() {
     return self::GRANULARITY_GLOBAL;
   }
 
   public function getLintNameMap() {
     return array(
       self::LINT_UNKNOWN_SYMBOL      => pht('Unknown Symbol'),
       self::LINT_DUPLICATE_SYMBOL    => pht('Duplicate Symbol'),
       self::LINT_ONE_CLASS_PER_FILE  => pht('One Class Per File'),
       self::LINT_NONCANONICAL_SYMBOL => pht('Noncanonical Symbol'),
     );
   }
 
   public function getLinterPriority() {
     return 2.0;
   }
 
   public function willLintPaths(array $paths) {
 
     $libtype_map = array(
       'class' => 'class',
       'function' => 'function',
       'interface' => 'class',
       'class/interface' => 'class',
     );
 
     // NOTE: For now, we completely ignore paths and just lint every library in
     // its entirety. This is simpler and relatively fast because we don't do any
     // detailed checks and all the data we need for this comes out of module
     // caches.
 
     $bootloader = PhutilBootloader::getInstance();
     $libraries  = $bootloader->getAllLibraries();
 
     // Load all the builtin symbols first.
     $builtin_map = PhutilLibraryMapBuilder::newBuiltinMap();
     $builtin_map = $builtin_map['have'];
 
     $normal_symbols = array();
     $all_symbols = array();
     foreach ($builtin_map as $type => $builtin_symbols) {
       $libtype = $libtype_map[$type];
       foreach ($builtin_symbols as $builtin_symbol => $ignored) {
         $normal_symbol = $this->normalizeSymbol($builtin_symbol);
         $normal_symbols[$type][$normal_symbol] = $builtin_symbol;
 
         $all_symbols[$libtype][$builtin_symbol] = array(
           'library' => null,
           'file' => null,
           'offset' => null,
         );
       }
     }
 
     // Load the up-to-date map for each library, without loading the library
     // itself. This means lint results will accurately reflect the state of
     // the working copy.
 
     $symbols = array();
 
     foreach ($libraries as $library) {
       $root = phutil_get_library_root($library);
 
       try {
         $symbols[$library] = id(new PhutilLibraryMapBuilder($root))
           ->buildFileSymbolMap();
       } catch (XHPASTSyntaxErrorException $ex) {
         // If the library contains a syntax error then there isn't much that we
         // can do.
         continue;
       }
     }
 
     foreach ($symbols as $library => $map) {
       // Check for files which declare more than one class/interface in the same
       // file, or mix function definitions with class/interface definitions. We
       // must isolate autoloadable symbols to one per file so the autoloader
       // can't end up in an unresolvable cycle.
       foreach ($map as $file => $spec) {
         $have = idx($spec, 'have', array());
 
         $have_classes =
           idx($have, 'class', array()) +
           idx($have, 'interface', array());
         $have_functions = idx($have, 'function');
 
         if ($have_functions && $have_classes) {
           $function_list = implode(', ', array_keys($have_functions));
           $class_list = implode(', ', array_keys($have_classes));
           $this->raiseLintInLibrary(
             $library,
             $file,
             end($have_functions),
             self::LINT_ONE_CLASS_PER_FILE,
             pht(
               "File '%s' mixes function (%s) and class/interface (%s) ".
               "definitions in the same file. A file which declares a class ".
               "or an interface MUST declare nothing else.",
               $file,
               $function_list,
               $class_list));
         } else if (count($have_classes) > 1) {
           $class_list = implode(', ', array_keys($have_classes));
           $this->raiseLintInLibrary(
             $library,
             $file,
             end($have_classes),
             self::LINT_ONE_CLASS_PER_FILE,
             pht(
               "File '%s' declares more than one class or interface (%s). ".
               "A file which declares a class or interface MUST declare ".
               "nothing else.",
               $file,
               $class_list));
         }
       }
 
       // Check for duplicate symbols: two files providing the same class or
       // function. While doing this, we also build a map of normalized symbol
       // names to original symbol names: we want a definition of "idx()" to
       // collide with a definition of "IdX()", and want to perform spelling
       // corrections later.
 
       foreach ($map as $file => $spec) {
         $have = idx($spec, 'have', array());
         foreach (array('class', 'function', 'interface') as $type) {
           $libtype = $libtype_map[$type];
           foreach (idx($have, $type, array()) as $symbol => $offset) {
             $normal_symbol = $this->normalizeSymbol($symbol);
 
             if (empty($normal_symbols[$libtype][$normal_symbol])) {
               $normal_symbols[$libtype][$normal_symbol] = $symbol;
               $all_symbols[$libtype][$symbol] = array(
                 'library' => $library,
                 'file'    => $file,
                 'offset'  => $offset,
               );
               continue;
             }
 
             $old_symbol = $normal_symbols[$libtype][$normal_symbol];
             $old_src = $all_symbols[$libtype][$old_symbol]['file'];
             $old_lib = $all_symbols[$libtype][$old_symbol]['library'];
 
             // If these values are "null", it means that the symbol is a
             // builtin symbol provided by PHP or a PHP extension.
 
             if ($old_lib === null) {
               $message = pht(
                 'Definition of symbol "%s" (of type "%s") in file "%s" in '.
                 'library "%s" duplicates builtin definition of the same '.
                 'symbol.',
                 $symbol,
                 $type,
                 $file,
                 $library);
             } else {
               $message = pht(
                 'Definition of symbol "%s" (of type "%s") in file "%s" in '.
                 'library "%s" duplicates prior definition in file "%s" in '.
                 'library "%s".',
                 $symbol,
                 $type,
                 $file,
                 $library,
                 $old_src,
                 $old_lib);
             }
 
             $this->raiseLintInLibrary(
               $library,
               $file,
               $offset,
               self::LINT_DUPLICATE_SYMBOL,
               $message);
           }
         }
       }
     }
 
     $types = array('class', 'function', 'interface', 'class/interface');
     foreach ($symbols as $library => $map) {
       // Check for unknown symbols: uses of classes, functions or interfaces
       // which are not defined anywhere. We reference the list of all symbols
       // we built up earlier.
       foreach ($map as $file => $spec) {
         $need = idx($spec, 'need', array());
         foreach ($types as $type) {
           $libtype = $libtype_map[$type];
           foreach (idx($need, $type, array()) as $symbol => $offset) {
             if (!empty($all_symbols[$libtype][$symbol])) {
               // Symbol is defined somewhere.
               continue;
             }
 
             $normal_symbol = $this->normalizeSymbol($symbol);
             if (!empty($normal_symbols[$libtype][$normal_symbol])) {
               $proper_symbol = $normal_symbols[$libtype][$normal_symbol];
 
               switch ($type) {
                 case 'class':
                   $summary = pht(
                     'Class symbol "%s" should be written as "%s".',
                     $symbol,
                     $proper_symbol);
                   break;
                 case 'function':
                   $summary = pht(
                     'Function symbol "%s" should be written as "%s".',
                     $symbol,
                     $proper_symbol);
                   break;
                 case 'interface':
                   $summary = pht(
                     'Interface symbol "%s" should be written as "%s".',
                     $symbol,
                     $proper_symbol);
                   break;
                 case 'class/interface':
                   $summary = pht(
                     'Class or interface symbol "%s" should be written as "%s".',
                     $symbol,
                     $proper_symbol);
                   break;
                 default:
                   throw new Exception(
                     pht('Unknown symbol type "%s".', $type));
               }
 
               $this->raiseLintInLibrary(
                 $library,
                 $file,
                 $offset,
                 self::LINT_NONCANONICAL_SYMBOL,
                 $summary,
                 $symbol,
                 $proper_symbol);
 
               continue;
             }
 
             $arcanist_root = dirname(phutil_get_library_root('arcanist'));
 
             switch ($type) {
               case 'class':
                 $summary = pht(
                   'Use of unknown class symbol "%s".',
                   $symbol);
                 break;
               case 'function':
                 $summary = pht(
                   'Use of unknown function symbol "%s".',
                   $symbol);
                 break;
               case 'interface':
                 $summary = pht(
                   'Use of unknown interface symbol "%s".',
                   $symbol);
                 break;
               case 'class/interface':
                 $summary = pht(
                   'Use of unknown class or interface symbol "%s".',
                   $symbol);
                 break;
             }
 
             $details = pht(
               "Common causes are:\n".
               "\n".
-              "  - Your copy of Arcanist is out of date.\n".
+              "  - Your copy of %s is out of date.\n".
               "    This is the most common cause.\n".
-              "    Update this copy of Arcanist:\n".
+              "    Update this copy of %s:\n".
               "\n".
               "      %s\n".
               "\n".
               "  - Some other library is out of date.\n".
               "    Update the library this symbol appears in.\n".
               "\n".
               "  - The symbol is misspelled.\n".
               "    Spell the symbol name correctly.\n".
               "\n".
               "  - You added the symbol recently, but have not updated\n".
               "    the symbol map for the library.\n".
               "    Run \"arc liberate\" in the library where the symbol is\n".
               "    defined.\n".
               "\n".
               "  - This symbol is defined in an external library.\n".
               "    Use \"@phutil-external-symbol\" to annotate it.\n".
               "    Use \"grep\" to find examples of usage.",
+              PlatformSymbols::getPlatformClientName(),
+              PlatformSymbols::getPlatformClientName(),
               $arcanist_root);
 
             $message = implode(
               "\n\n",
               array(
                 $summary,
                 $details,
               ));
 
             $this->raiseLintInLibrary(
               $library,
               $file,
               $offset,
               self::LINT_UNKNOWN_SYMBOL,
               $message);
           }
         }
       }
     }
   }
 
   private function raiseLintInLibrary(
     $library,
     $path,
     $offset,
     $code,
     $desc,
     $original = null,
     $replacement = null) {
     $root = phutil_get_library_root($library);
 
     $this->activePath = $root.'/'.$path;
     $this->raiseLintAtOffset($offset, $code, $desc, $original, $replacement);
   }
 
   public function lintPath($path) {
     return;
   }
 
   private function normalizeSymbol($symbol) {
     return phutil_utf8_strtolower($symbol);
   }
 
 }
diff --git a/src/lint/linter/xhpast/rules/ArcanistProductNameLiteralXHPASTLinterRule.php b/src/lint/linter/xhpast/rules/ArcanistProductNameLiteralXHPASTLinterRule.php
new file mode 100644
index 00000000..20f3e453
--- /dev/null
+++ b/src/lint/linter/xhpast/rules/ArcanistProductNameLiteralXHPASTLinterRule.php
@@ -0,0 +1,67 @@
+<?php
+
+final class ArcanistProductNameLiteralXHPASTLinterRule
+  extends ArcanistXHPASTLinterRule {
+
+  const ID = 134;
+
+  public function getLintName() {
+    return pht('Use of Product Name Literal');
+  }
+
+  public function getLintSeverity() {
+    return ArcanistLintSeverity::SEVERITY_WARNING;
+  }
+
+  public function process(XHPASTNode $root) {
+    $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
+
+    $product_names = PlatformSymbols::getProductNames();
+    foreach ($product_names as $k => $product_name) {
+      $product_names[$k] = preg_quote($product_name);
+    }
+
+    $search_pattern = '(\b(?:'.implode('|', $product_names).')\b)i';
+
+    foreach ($calls as $call) {
+      $name = $call->getChildByIndex(0)->getConcreteString();
+
+      if ($name !== 'pht') {
+        continue;
+      }
+
+      $parameters = $call->getChildByIndex(1);
+
+      if (!$parameters->getChildren()) {
+        continue;
+      }
+
+      $identifier = $parameters->getChildByIndex(0);
+      if (!$identifier->isConstantString()) {
+        continue;
+      }
+
+      $literal_value = $identifier->evalStatic();
+
+      $matches = phutil_preg_match_all($search_pattern, $literal_value);
+      if (!$matches[0]) {
+        continue;
+      }
+
+      $name_list = array();
+      foreach ($matches[0] as $match) {
+        $name_list[phutil_utf8_strtolower($match)] = $match;
+      }
+      $name_list = implode(', ', $name_list);
+
+      $this->raiseLintAtNode(
+        $identifier,
+        pht(
+          'Avoid use of product name literals in "pht()": use generic '.
+          'language or an appropriate method from the "PlatformSymbols" class '.
+          'instead so the software can be forked. String uses names: %s.',
+          $name_list));
+    }
+  }
+
+}
diff --git a/src/log/ArcanistLogEngine.php b/src/log/ArcanistLogEngine.php
index 11f6918b..c2d19c13 100644
--- a/src/log/ArcanistLogEngine.php
+++ b/src/log/ArcanistLogEngine.php
@@ -1,105 +1,105 @@
 <?php
 
 final class ArcanistLogEngine
   extends Phobject {
 
   private $showTraceMessages;
 
   public function setShowTraceMessages($show_trace_messages) {
     $this->showTraceMessages = $show_trace_messages;
     return $this;
   }
 
   public function getShowTraceMessages() {
     return $this->showTraceMessages;
   }
 
   public function newMessage() {
     return new ArcanistLogMessage();
   }
 
   private function writeBytes($bytes) {
-    fprintf(STDERR, '%s', $bytes);
+    PhutilSystem::writeStderr($bytes);
     return $this;
   }
 
   public function writeNewline() {
     return $this->writeBytes("\n");
   }
 
   public function writeMessage(ArcanistLogMessage $message) {
     $color = $message->getColor();
 
     $this->writeBytes(
       tsprintf(
         "**<bg:".$color."> %s </bg>** %s\n",
         $message->getLabel(),
         $message->getMessage()));
 
     return $message;
   }
 
   public function writeWarning($label, $message) {
     return $this->writeMessage(
       $this->newMessage()
         ->setColor('yellow')
         ->setLabel($label)
         ->setMessage($message));
   }
 
   public function writeError($label, $message) {
     return $this->writeMessage(
       $this->newMessage()
         ->setColor('red')
         ->setLabel($label)
         ->setMessage($message));
   }
 
   public function writeSuccess($label, $message) {
     return $this->writeMessage(
       $this->newMessage()
         ->setColor('green')
         ->setLabel($label)
         ->setMessage($message));
   }
 
   public function writeStatus($label, $message) {
     return $this->writeMessage(
       $this->newMessage()
         ->setColor('blue')
         ->setLabel($label)
         ->setMessage($message));
   }
 
   public function writeTrace($label, $message) {
     $trace = $this->newMessage()
       ->setColor('magenta')
       ->setLabel($label)
       ->setMessage($message);
 
     if ($this->getShowTraceMessages()) {
       $this->writeMessage($trace);
     }
 
     return $trace;
   }
 
   public function writeHint($label, $message) {
     return $this->writeMessage(
       $this->newMessage()
         ->setColor('cyan')
         ->setLabel($label)
         ->setMessage($message));
   }
 
   public function writeWaitingForInput() {
     if (!phutil_is_interactive()) {
       return;
     }
 
     $this->writeStatus(
       pht('INPUT'),
       pht('Waiting for input on stdin...'));
   }
 
 }
diff --git a/src/parser/ArcanistBaseCommitParser.php b/src/parser/ArcanistBaseCommitParser.php
index 5ed6ce4a..2c886bd6 100644
--- a/src/parser/ArcanistBaseCommitParser.php
+++ b/src/parser/ArcanistBaseCommitParser.php
@@ -1,208 +1,208 @@
 <?php
 
 final class ArcanistBaseCommitParser extends Phobject {
 
   private $api;
   private $try;
   private $verbose = false;
 
   public function __construct(ArcanistRepositoryAPI $api) {
     $this->api = $api;
   }
 
   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(
           pht(
             "Rule '%s' is invalid, it must have a type and name like '%s'.",
             $rule,
             'arc:upstream'));
       }
     }
 
     return $spec;
   }
 
   private function log($message) {
     if ($this->verbose) {
-      fwrite(STDERR, $message."\n");
+      PhutilSystem::writeStderr($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(pht("No rules left from source '%s'.", $source));
         array_shift($this->try);
         continue;
       }
 
       $this->log(pht("Trying rules from source '%s'.", $source));
 
       $rules = &$specs[$source];
       while ($rule = array_shift($rules)) {
         $this->log(pht("Trying rule '%s'.", $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(pht(
             "Resolved commit '%s' from rule '%s'.",
             $commit,
             $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(
           pht(
             "Base commit rule '%s' (from source '%s') ".
             "is not a recognized rule.",
             $rule,
             $source));
     }
   }
 
 
   /**
    * Handle resolving "arc:*" rules.
    */
   private function resolveArcRule($rule, $name, $source) {
     $name = $this->updateLegacyRuleName($name);
 
     switch ($name) {
       case 'verbose':
         $this->verbose = true;
         $this->log(pht('Enabled verbose mode.'));
         break;
       case 'prompt':
         $reason = pht('it is what you typed when prompted.');
         $this->api->setBaseCommitExplanation($reason);
         $result = phutil_console_prompt(pht('Against which commit?'));
         if (!strlen($result)) {
           // Allow the user to continue to the next rule by entering no
           // text.
           return null;
         }
         return $result;
       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(pht("Switching to source '%s'.", $name));
         return false;
       case 'yield':
         // Cycle this source to the end of the list.
         $this->try[] = array_shift($this->try);
         $this->log(pht("Yielding processing of rules from '%s'.", $source));
         return false;
       case 'halt':
         // Dump the whole stack.
         $this->try = array();
         $this->log(pht('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(
           pht(
             "Base commit rule '%s' (from source '%s') ".
             "is not a recognized rule.",
             $rule,
             $source));
     }
   }
 
   private function updateLegacyRuleName($name) {
     $updated = array(
       'global' => 'user',
       'args'   => 'runtime',
     );
     $new_name = idx($updated, $name);
     if ($new_name) {
       $this->log(pht("Translating legacy name '%s' to '%s'", $name, $new_name));
       return $new_name;
     }
     return $name;
   }
 
 }
diff --git a/src/parser/PhutilEmailAddress.php b/src/parser/PhutilEmailAddress.php
index d02c4bce..76ea287c 100644
--- a/src/parser/PhutilEmailAddress.php
+++ b/src/parser/PhutilEmailAddress.php
@@ -1,115 +1,116 @@
 <?php
 
 /**
  * Basic email address parser. This parser is very liberal and does not attempt
  * to be fully RFC-compliant, because trying to do so is a crazy mess. However,
  * it should parse all reasonable addresses which are actually in use on the
  * internet today.
  */
 final class PhutilEmailAddress extends Phobject {
 
   private $displayName;
   private $localPart;
   private $domainName;
 
   public function __construct($email_address = null) {
     $email_address = phutil_string_cast($email_address);
     $email_address = trim($email_address);
 
     $matches = null;
     if (preg_match('/^(.*)<(.*?)>$/', $email_address, $matches)) {
       $display_name = trim($matches[1], '\'" ');
       if (strpos($matches[2], '@') !== false) {
         list($local_part, $domain_name) = explode('@', $matches[2], 2);
       } else {
         $local_part = $matches[2];
         $domain_name = null;
       }
     } else if (preg_match('/^(.*)@(.*)$/', $email_address, $matches)) {
       $display_name = null;
       $local_part = $matches[1];
       $domain_name = $matches[2];
     } else {
       $display_name = null;
       $local_part = $email_address;
       $domain_name = null;
     }
 
     $this->displayName = $display_name;
     $this->localPart = $local_part;
     $this->domainName = $domain_name;
   }
 
   public function __toString() {
     $address = $this->getAddress();
-    if (strlen($this->displayName)) {
+
+    if (phutil_nonempty_string($this->displayName)) {
       $display_name = $this->encodeDisplayName($this->displayName);
       return $display_name.' <'.$address.'>';
-    } else {
-      return $address;
     }
+
+    return $address;
   }
 
   public function setDisplayName($display_name) {
     $this->displayName = $display_name;
     return $this;
   }
 
   public function getDisplayName() {
     return $this->displayName;
   }
 
   public function setLocalPart($local_part) {
     $this->localPart = $local_part;
     return $this;
   }
 
   public function getLocalPart() {
     return $this->localPart;
   }
 
   public function setDomainName($domain_name) {
     $this->domainName = $domain_name;
     return $this;
   }
 
   public function getDomainName() {
     return $this->domainName;
   }
 
   public function setAddress($address) {
     $parts = explode('@', $address, 2);
 
     $this->localPart = $parts[0];
     if (isset($parts[1])) {
       $this->domainName = $parts[1];
     }
 
     return $this;
   }
 
   public function getAddress() {
     $address = $this->localPart;
     if ($this->domainName !== null && strlen($this->domainName)) {
       $address .= '@'.$this->domainName;
     }
     return $address;
   }
 
   private function encodeDisplayName($name) {
     // NOTE: This is a reasonable effort based on a cursory reading of
     // RFC2822, but may be significantly misguided.
 
     // Newlines are not permitted, even when escaped. Discard them.
     $name = preg_replace("/\s*[\r\n]+\s*/", ' ', $name);
 
     // Escape double quotes and backslashes.
     $name = addcslashes($name, '\\"');
 
     // Quote the string.
     $name = '"'.$name.'"';
 
     return $name;
   }
 
 }
diff --git a/src/parser/PhutilURI.php b/src/parser/PhutilURI.php
index d9701fb0..1a0f3895 100644
--- a/src/parser/PhutilURI.php
+++ b/src/parser/PhutilURI.php
@@ -1,564 +1,564 @@
 <?php
 
 /**
  * Structural representation of a URI.
  *
  * This class handles URIs of two types: standard URIs and Git URIs.
  *
  * Standard URIs look like `proto://user:pass@domain:port/path?query#fragment`.
  * Almost all URIs are in this form.
  *
  * Git URIs look like `user@host:path`. These URIs are used by Git and SCP
  * and have an implicit "ssh" protocol, no port, and interpret paths as
  * relative instead of absolute.
  */
 final class PhutilURI extends Phobject {
 
   private $protocol;
   private $user;
   private $pass;
   private $domain;
   private $port;
   private $path;
   private $query = array();
   private $fragment;
   private $type;
 
   const TYPE_URI = 'uri';
   const TYPE_GIT = 'git';
 
   public function __construct($uri, $params = array()) {
     if ($uri instanceof PhutilURI) {
       $this->protocol = $uri->protocol;
       $this->user = $uri->user;
       $this->pass = $uri->pass;
       $this->domain = $uri->domain;
       $this->port = $uri->port;
       $this->path = $uri->path;
       $this->query = $uri->query;
       $this->fragment = $uri->fragment;
       $this->type = $uri->type;
 
       $this->initializeQueryParams(phutil_string_cast($uri), $params);
 
       return;
     }
 
     $uri = phutil_string_cast($uri);
 
     $type = self::TYPE_URI;
 
     // Reject ambiguous URIs outright. Different versions of different clients
     // parse these in different ways. See T12526 for discussion.
     if (preg_match('(^[^/:]*://[^/]*[#?].*:)', $uri)) {
       throw new Exception(
         pht(
           'Rejecting ambiguous URI "%s". This URI is not formatted or '.
           'encoded properly.',
           $uri));
     }
 
     $matches = null;
     if (preg_match('(^([^/:]*://[^/]*)(\\?.*)\z)', $uri, $matches)) {
       // If the URI is something like `idea://open?file=/path/to/file`, the
       // `parse_url()` function will parse `open?file=` as the host. This is
       // not the expected result. Break the URI into two pieces, stick a slash
       // in between them, parse that, then remove the path. See T6106.
 
       $parts = parse_url($matches[1].'/'.$matches[2]);
       unset($parts['path']);
     } else if ($this->isGitURIPattern($uri)) {
       // Handle Git/SCP URIs in the form "user@domain:relative/path".
 
       $user = '(?:(?P<user>[^/@]+)@)?';
       $host = '(?P<host>[^/:]+)';
       $path = ':(?P<path>.*)';
 
       $ok = preg_match('(^'.$user.$host.$path.'\z)', $uri, $matches);
       if (!$ok) {
         throw new Exception(
           pht(
             'Failed to parse URI "%s" as a Git URI.',
             $uri));
       }
 
       $parts = $matches;
       $parts['scheme'] = 'ssh';
 
       $type = self::TYPE_GIT;
     } else {
       $parts = parse_url($uri);
     }
 
     // The parse_url() call will accept URIs with leading whitespace, but many
     // other tools (like git) will not. See T4913 for a specific example. If
     // the input string has leading whitespace, fail the parse.
     if ($parts) {
       if (ltrim($uri) != $uri) {
         $parts = false;
       }
     }
 
     // NOTE: `parse_url()` is very liberal about host names; fail the parse if
     // the host looks like garbage. In particular, we do not allow hosts which
     // begin with "." or "-". See T12961 for a specific attack which relied on
     // hosts beginning with "-".
     if ($parts) {
       $host = idx($parts, 'host', '');
       if (strlen($host)) {
         if (!preg_match('/^[a-zA-Z0-9]+[a-zA-Z0-9\\.\\-]*\z/', $host)) {
           $parts = false;
         }
       }
     }
 
     if (!$parts) {
       $parts = array();
     }
 
     // stringyness is to preserve API compatibility and
     // allow the tests to continue passing
     $this->protocol = idx($parts, 'scheme', '');
     $this->user = rawurldecode(idx($parts, 'user', ''));
     $this->pass = rawurldecode(idx($parts, 'pass', ''));
     $this->domain = idx($parts, 'host', '');
     $this->port = (string)idx($parts, 'port', '');
     $this->path = idx($parts, 'path', '');
     $query = idx($parts, 'query');
     if ($query) {
       $pairs = id(new PhutilQueryStringParser())
         ->parseQueryStringToPairList($query);
 
       foreach ($pairs as $pair) {
         list($key, $value) = $pair;
         $this->appendQueryParam($key, $value);
       }
     }
     $this->fragment = idx($parts, 'fragment', '');
 
     $this->type = $type;
 
     $this->initializeQueryParams($uri, $params);
   }
 
   public function __toString() {
     $prefix = null;
 
     if ($this->isGitURI()) {
       $port = null;
     } else {
       $port = $this->port;
     }
 
     $domain = $this->domain;
 
     $user = $this->user;
     $pass = $this->pass;
-    if (strlen($user) && strlen($pass)) {
+    if (phutil_nonempty_string($user) && phutil_nonempty_string($pass)) {
       $auth = rawurlencode($user).':'.rawurlencode($pass).'@';
-    } else if (strlen($user)) {
+    } else if (phutil_nonempty_string($user)) {
       $auth = rawurlencode($user).'@';
     } else {
       $auth = null;
     }
 
     $protocol = $this->protocol;
     if ($this->isGitURI()) {
       $protocol = null;
     } else {
       if ($auth !== null) {
         $protocol = nonempty($this->protocol, 'http');
       }
     }
 
     $has_protocol = ($protocol !== null) && strlen($protocol);
     $has_auth = ($auth !== null);
     $has_domain = ($domain !== null) && strlen($domain);
     $has_port = ($port !== null) && strlen($port);
 
     if ($has_protocol || $has_auth || $has_domain) {
       if ($this->isGitURI()) {
         $prefix = "{$auth}{$domain}";
       } else {
         $prefix = "{$protocol}://{$auth}{$domain}";
       }
 
       if ($has_port) {
         $prefix .= ':'.$port;
       }
     }
 
     if ($this->query) {
       $query = '?'.phutil_build_http_querystring_from_pairs($this->query);
     } else {
       $query = null;
     }
 
-    if (strlen($this->getFragment())) {
+    if (phutil_nonempty_string($this->getFragment())) {
       $fragment = '#'.$this->getFragment();
     } else {
       $fragment = null;
     }
 
     $path = $this->getPath();
     if ($this->isGitURI()) {
       if (strlen($path)) {
         $path = ':'.$path;
       }
     }
 
     return $prefix.$path.$query.$fragment;
   }
 
   /**
    * @deprecated
    */
   public function setQueryParam($key, $value) {
     // To set, we replace the first matching key with the new value, then
     // remove all other matching keys. This replaces the old value and retains
     // the parameter order.
 
     $is_null = ($value === null);
 
     // Typecheck and cast the key before we compare it to existing keys. This
     // raises an early exception if the key has a bad type.
     list($key) = phutil_http_parameter_pair($key, '');
 
     $found = false;
     foreach ($this->query as $list_key => $pair) {
       list($k, $v) = $pair;
 
       if ($k !== $key) {
         continue;
       }
 
       if ($found) {
         unset($this->query[$list_key]);
         continue;
       }
 
       $found = true;
 
       if ($is_null) {
         unset($this->query[$list_key]);
       } else {
         $this->insertQueryParam($key, $value, $list_key);
       }
     }
 
     $this->query = array_values($this->query);
 
     // If we didn't find an existing place to put it, add it to the end.
     if (!$found) {
       if (!$is_null) {
         $this->appendQueryParam($key, $value);
       }
     }
 
     return $this;
   }
 
   /**
    * @deprecated
    */
   public function setQueryParams(array $params) {
     $this->query = array();
 
     foreach ($params as $k => $v) {
       $this->appendQueryParam($k, $v);
     }
 
     return $this;
   }
 
   /**
    * @deprecated
    */
   public function getQueryParams() {
     $map = array();
 
     foreach ($this->query as $pair) {
       list($k, $v) = $pair;
       $map[$k] = $v;
     }
 
     return $map;
   }
 
   public function getQueryParamsAsMap() {
     $map = array();
 
     foreach ($this->query as $pair) {
       list($k, $v) = $pair;
 
       if (isset($map[$k])) {
         throw new Exception(
           pht(
             'Query parameters include a duplicate key ("%s") and can not be '.
             'nondestructively represented as a map.',
             $k));
       }
 
       $map[$k] = $v;
     }
 
     return $map;
   }
 
   public function getQueryParamsAsPairList() {
     return $this->query;
   }
 
   public function appendQueryParam($key, $value) {
     return $this->insertQueryParam($key, $value);
   }
 
   public function removeAllQueryParams() {
     $this->query = array();
     return $this;
   }
 
   public function removeQueryParam($remove_key) {
     list($remove_key) = phutil_http_parameter_pair($remove_key, '');
 
     foreach ($this->query as $idx => $pair) {
       list($key, $value) = $pair;
 
       if ($key !== $remove_key) {
         continue;
       }
 
       unset($this->query[$idx]);
     }
 
     $this->query = array_values($this->query);
 
     return $this;
   }
 
   public function replaceQueryParam($replace_key, $replace_value) {
     if ($replace_value === null) {
       throw new InvalidArgumentException(
         pht(
           'Value provided to "replaceQueryParam()" for key "%s" is NULL. '.
           'Use "removeQueryParam()" to remove a query parameter.',
           $replace_key));
     }
 
     $this->removeQueryParam($replace_key);
     $this->appendQueryParam($replace_key, $replace_value);
     return $this;
   }
 
   private function insertQueryParam($key, $value, $idx = null) {
     list($key, $value) = phutil_http_parameter_pair($key, $value);
 
     if ($idx === null) {
       $this->query[] = array($key, $value);
     } else {
       $this->query[$idx] = array($key, $value);
     }
 
     return $this;
   }
 
   private function initializeQueryParams($uri, array $params) {
     $have_params = array();
     foreach ($this->query as $pair) {
       list($key) = $pair;
       $have_params[$key] = true;
     }
 
     foreach ($params as $key => $value) {
       if (isset($have_params[$key])) {
         throw new InvalidArgumentException(
           pht(
             'You are trying to construct an ambiguous URI: query parameter '.
             '"%s" is present in both the string argument ("%s") and the map '.
             'argument.',
             $key,
             $uri));
       }
 
       if ($value === null) {
         continue;
       }
 
       $this->appendQueryParam($key, $value);
     }
 
     return $this;
   }
 
   public function setProtocol($protocol) {
     $this->protocol = $protocol;
     return $this;
   }
 
   public function getProtocol() {
     return $this->protocol;
   }
 
   public function setDomain($domain) {
     $this->domain = $domain;
     return $this;
   }
 
   public function getDomain() {
     return $this->domain;
   }
 
   public function setPort($port) {
     $this->port = $port;
     return $this;
   }
   public function getPort() {
     return $this->port;
   }
 
   public function getPortWithProtocolDefault() {
     static $default_ports = array(
       'http'  => '80',
       'https' => '443',
       'ssh'   => '22',
     );
 
     return nonempty(
       $this->getPort(),
       idx($default_ports, $this->getProtocol()),
       '');
   }
 
   public function setPath($path) {
     if ($this->isGitURI()) {
       // Git URIs use relative paths which do not need to begin with "/".
     } else {
-      if ($this->domain && strlen($path) && $path[0] !== '/') {
+      if ($this->domain && phutil_nonempty_string($path) && $path[0] !== '/') {
         $path = '/'.$path;
       }
     }
 
     $this->path = $path;
     return $this;
   }
 
   public function appendPath($path) {
     $first = strlen($path) ? $path[0] : null;
     $last  = strlen($this->path) ? $this->path[strlen($this->path) - 1] : null;
 
     if (!$this->path) {
       return $this->setPath($path);
     } else if ($first === '/' && $last === '/') {
       $path = substr($path, 1);
     } else if ($first !== '/' && $last !== '/') {
       $path = '/'.$path;
     }
 
     $this->path .= $path;
     return $this;
   }
 
   public function getPath() {
     return $this->path;
   }
 
   public function setFragment($fragment) {
     $this->fragment = $fragment;
     return $this;
   }
 
   public function getFragment() {
     return $this->fragment;
   }
 
   public function setUser($user) {
     $this->user = $user;
     return $this;
   }
 
   public function getUser() {
     return $this->user;
   }
 
   public function setPass($pass) {
     $this->pass = $pass;
     return $this;
   }
 
   public function getPass() {
     return $this->pass;
   }
 
   public function alter($key, $value) {
     $altered = clone $this;
     $altered->replaceQueryParam($key, $value);
     return $altered;
   }
 
   public function isGitURI() {
     return ($this->type == self::TYPE_GIT);
   }
 
   public function setType($type) {
 
     if ($type == self::TYPE_URI) {
       $path = $this->getPath();
       if (strlen($path) && ($path[0] !== '/')) {
         // Try to catch this here because we are not allowed to throw from
         // inside __toString() so we don't have a reasonable opportunity to
         // react properly if we catch it later.
         throw new Exception(
           pht(
             'Unable to convert URI "%s" into a standard URI because the '.
             'path is relative. Standard URIs can not represent relative '.
             'paths.',
             $this));
       }
     }
 
     $this->type = $type;
     return $this;
   }
 
   public function getType() {
     return $this->type;
   }
 
   private function isGitURIPattern($uri) {
     $matches = null;
 
     $ok = preg_match('(^(?P<head>[^/]+):(?P<last>(?!//).*)\z)', $uri, $matches);
     if (!$ok) {
       return false;
     }
 
     $head = $matches['head'];
     $last = $matches['last'];
 
     // If any part of this has spaces in it, it's not a Git URI. We fail here
     // so we fall back and don't fail more abruptly later.
     if (preg_match('(\s)', $head.$last)) {
       return false;
     }
 
     // If the second part only contains digits, assume we're looking at
     // casually specified "domain.com:123" URI, not a Git URI pointed at an
     // entirely numeric relative path.
     if (preg_match('(^\d+\z)', $last)) {
       return false;
     }
 
     // If the first part has a "." or an "@" in it, interpret it as a domain
     // or a "user@host" string.
     if (preg_match('([.@])', $head)) {
       return true;
     }
 
     // Otherwise, interpret the URI conservatively as a "javascript:"-style
     // URI. This means that "localhost:path" is parsed as a normal URI instead
     // of a Git URI, but we can't tell which the user intends and it's safer
     // to treat it as a normal URI.
     return false;
   }
 
 }
diff --git a/src/parser/argument/PhutilArgumentParser.php b/src/parser/argument/PhutilArgumentParser.php
index 1bf31a23..6391fd83 100644
--- a/src/parser/argument/PhutilArgumentParser.php
+++ b/src/parser/argument/PhutilArgumentParser.php
@@ -1,1017 +1,1044 @@
 <?php
 
 /**
  * Parser for command-line arguments for scripts. Like similar parsers, this
  * class allows you to specify, validate, and render help for command-line
  * arguments. For example:
  *
  *   name=create_dog.php
  *   $args = new PhutilArgumentParser($argv);
  *   $args->setTagline('make an new dog')
  *   $args->setSynopsis(<<<EOHELP
  *   **dog** [--big] [--name __name__]
  *   Create a new dog. How does it work? Who knows.
  *   EOHELP
  *   );
  *   $args->parse(
  *     array(
  *       array(
  *         'name'     => 'name',
  *         'param'    => 'dogname',
  *         'default'  => 'Rover',
  *         'help'     => 'Set the dog\'s name. By default, the dog will be '.
  *                       'named "Rover".',
  *       ),
  *       array(
  *         'name'     => 'big',
  *         'short'    => 'b',
  *         'help'     => 'If set, create a large dog.',
  *       ),
  *     ));
  *
  *   $dog_name = $args->getArg('name');
  *   $dog_size = $args->getArg('big') ? 'big' : 'small';
  *
  *   // ... etc ...
  *
  * (For detailed documentation on supported keys in argument specifications,
  * see @{class:PhutilArgumentSpecification}.)
  *
  * This will handle argument parsing, and generate appropriate usage help if
  * the user provides an unsupported flag. @{class:PhutilArgumentParser} also
  * supports some builtin "standard" arguments:
  *
  *   $args->parseStandardArguments();
  *
  * See @{method:parseStandardArguments} for details. Notably, this includes
  * a "--help" flag, and an "--xprofile" flag for profiling command-line scripts.
  *
  * Normally, when the parser encounters an unknown flag, it will exit with
  * an error. However, you can use @{method:parsePartial} to consume only a
  * set of flags:
  *
  *   $args->parsePartial($spec_list);
  *
  * This allows you to parse some flags before making decisions about other
  * parsing, or share some flags across scripts. The builtin standard arguments
  * are implemented in this way.
  *
  * There is also builtin support for "workflows", which allow you to build a
  * script that operates in several modes (e.g., by accepting commands like
  * `install`, `upgrade`, etc), like `arc` does. For detailed documentation on
  * workflows, see @{class:PhutilArgumentWorkflow}.
  *
  * @task parse    Parsing Arguments
  * @task read     Reading Arguments
  * @task help     Command Help
  * @task internal Internals
  */
 final class PhutilArgumentParser extends Phobject {
 
   private $bin;
   private $argv;
   private $specs = array();
   private $results = array();
   private $parsed;
 
   private $tagline;
   private $synopsis;
   private $workflows;
   private $helpWorkflows;
   private $showHelp;
   private $requireArgumentTerminator = false;
   private $sawTerminator = false;
 
   const PARSE_ERROR_CODE = 77;
 
   private static $traceModeEnabled = false;
 
 
 /* -(  Parsing Arguments  )-------------------------------------------------- */
 
 
   /**
    * Build a new parser. Generally, you start a script with:
    *
    *   $args = new PhutilArgumentParser($argv);
    *
    * @param list  Argument vector to parse, generally the $argv global.
    * @task parse
    */
   public function __construct(array $argv) {
     $this->bin = $argv[0];
     $this->argv = array_slice($argv, 1);
   }
 
 
   /**
    * Parse and consume a list of arguments, removing them from the argument
    * vector but leaving unparsed arguments for later consumption. You can
    * retrieve unconsumed arguments directly with
    * @{method:getUnconsumedArgumentVector}. Doing a partial parse can make it
    * easier to share common flags across scripts or workflows.
    *
    * @param   list  List of argument specs, see
    *                @{class:PhutilArgumentSpecification}.
    * @param bool Require flags appear before any non-flag arguments.
    * @return  this
    * @task parse
    */
   public function parsePartial(array $specs, $initial_only = false) {
     return $this->parseInternal($specs, false, $initial_only);
   }
 
   /**
    * @return  this
    */
   private function parseInternal(
     array $specs,
     $correct_spelling,
     $initial_only) {
 
     $specs = PhutilArgumentSpecification::newSpecsFromList($specs);
     $this->mergeSpecs($specs);
 
     // Wildcard arguments have a name like "argv", but we don't want to
     // parse a corresponding flag like "--argv". Filter them out before
     // building a list of available flags.
     $non_wildcard = array();
     foreach ($specs as $spec_key => $spec) {
       if ($spec->getWildcard()) {
         continue;
       }
 
       $non_wildcard[$spec_key] = $spec;
     }
 
     $specs_by_name  = mpull($non_wildcard, null, 'getName');
     $specs_by_short = mpull($non_wildcard, null, 'getShortAlias');
     unset($specs_by_short[null]);
 
     $argv = $this->argv;
     $len = count($argv);
     $is_initial = true;
     for ($ii = 0; $ii < $len; $ii++) {
       $arg = $argv[$ii];
       $map = null;
       $options = null;
       if (!is_string($arg)) {
         // Non-string argument; pass it through as-is.
       } else if ($arg == '--') {
         // This indicates "end of flags".
         $this->sawTerminator = true;
         break;
       } else if ($arg == '-') {
         // This is a normal argument (e.g., stdin).
         continue;
       } else if (!strncmp('--', $arg, 2)) {
         $pre = '--';
         $arg = substr($arg, 2);
         $map = $specs_by_name;
         $options = array_keys($specs_by_name);
       } else if (!strncmp('-', $arg, 1) && strlen($arg) > 1) {
         $pre = '-';
         $arg = substr($arg, 1);
         $map = $specs_by_short;
       } else {
         $is_initial = false;
       }
 
       if ($map) {
         $val = null;
         $parts = explode('=', $arg, 2);
         if (count($parts) == 2) {
           list($arg, $val) = $parts;
         }
 
         // Try to correct flag spelling for full flags, to allow users to make
         // minor mistakes.
         if ($correct_spelling && $options && !isset($map[$arg])) {
           $corrections = PhutilArgumentSpellingCorrector::newFlagCorrector()
             ->correctSpelling($arg, $options);
 
           $should_autocorrect = $this->shouldAutocorrect();
           if (count($corrections) == 1 && $should_autocorrect) {
             $corrected = head($corrections);
 
             $this->logMessage(
               tsprintf(
                 "%s\n",
                 pht(
                   '(Assuming "%s" is the British spelling of "%s".)',
                   $pre.$arg,
                   $pre.$corrected)));
 
             $arg = $corrected;
           }
         }
 
         if (isset($map[$arg])) {
           if ($initial_only && !$is_initial) {
             throw new PhutilArgumentUsageException(
               pht(
                 'Argument "%s" appears after the first non-flag argument. '.
                 'This special argument must appear before other arguments.',
                 "{$pre}{$arg}"));
           }
 
           $spec = $map[$arg];
           unset($argv[$ii]);
 
           $param_name = $spec->getParamName();
           if ($val !== null) {
             if ($param_name === null) {
               throw new PhutilArgumentUsageException(
                 pht(
                   'Argument "%s" does not take a parameter.',
                   "{$pre}{$arg}"));
             }
           } else {
             if ($param_name !== null) {
               if ($ii + 1 < $len) {
                 $val = $argv[$ii + 1];
                 unset($argv[$ii + 1]);
                 $ii++;
               } else {
                 throw new PhutilArgumentUsageException(
                   pht(
                     'Argument "%s" requires a parameter.',
                     "{$pre}{$arg}"));
               }
             } else {
               $val = true;
             }
           }
 
           if (!$spec->getRepeatable()) {
             if (array_key_exists($spec->getName(), $this->results)) {
               throw new PhutilArgumentUsageException(
                 pht(
                   'Argument "%s" was provided twice.',
                   "{$pre}{$arg}"));
             }
           }
 
           $conflicts = $spec->getConflicts();
           foreach ($conflicts as $conflict => $reason) {
             if (array_key_exists($conflict, $this->results)) {
 
               if (!is_string($reason) || !strlen($reason)) {
                 $reason = '.';
               } else {
                 $reason = ': '.$reason.'.';
               }
 
               throw new PhutilArgumentUsageException(
                 pht(
                   'Argument "%s" conflicts with argument "%s"%s',
                   "{$pre}{$arg}",
                   "--{$conflict}",
                   $reason));
             }
           }
 
           if ($spec->getRepeatable()) {
             if ($spec->getParamName() === null) {
               if (empty($this->results[$spec->getName()])) {
                 $this->results[$spec->getName()] = 0;
               }
               $this->results[$spec->getName()]++;
             } else {
               $this->results[$spec->getName()][] = $val;
             }
           } else {
             $this->results[$spec->getName()] = $val;
           }
         }
       }
     }
 
     foreach ($specs as $spec) {
       if ($spec->getWildcard()) {
         $this->results[$spec->getName()] = $this->filterWildcardArgv($argv);
         $argv = array();
         break;
       }
     }
 
     $this->argv = array_values($argv);
 
     return $this;
   }
 
 
   /**
    * Parse and consume a list of arguments, throwing an exception if there is
    * anything left unconsumed. This is like @{method:parsePartial}, but raises
    * a {class:PhutilArgumentUsageException} if there are leftovers.
    *
    * Normally, you would call @{method:parse} instead, which emits a
    * user-friendly error. You can also use @{method:printUsageException} to
    * render the exception in a user-friendly way.
    *
    * @param   list  List of argument specs, see
    *                @{class:PhutilArgumentSpecification}.
    * @return  this
    * @task parse
    */
   public function parseFull(array $specs) {
     $this->parseInternal($specs, true, false);
 
     // If we have remaining unconsumed arguments other than a single "--",
     // fail.
     $argv = $this->filterWildcardArgv($this->argv);
     if ($argv) {
       throw new PhutilArgumentUsageException(
         pht(
           'Unrecognized argument "%s".',
           head($argv)));
     }
 
     if ($this->getRequireArgumentTerminator()) {
       if (!$this->sawTerminator) {
         throw new ArcanistMissingArgumentTerminatorException();
       }
     }
 
     if ($this->showHelp) {
       $this->printHelpAndExit();
     }
 
     return $this;
   }
 
 
   /**
    * Parse and consume a list of arguments, raising a user-friendly error if
    * anything remains. See also @{method:parseFull} and @{method:parsePartial}.
    *
    * @param   list  List of argument specs, see
    *                @{class:PhutilArgumentSpecification}.
    * @return  this
    * @task parse
    */
   public function parse(array $specs) {
     try {
       return $this->parseFull($specs);
     } catch (PhutilArgumentUsageException $ex) {
       $this->printUsageException($ex);
       exit(self::PARSE_ERROR_CODE);
     }
   }
 
 
   /**
    * Parse and execute workflows, raising a user-friendly error if anything
    * remains. See also @{method:parseWorkflowsFull}.
    *
    * See @{class:PhutilArgumentWorkflow} for details on using workflows.
    *
    * @param   list  List of argument specs, see
    *                @{class:PhutilArgumentSpecification}.
    * @return  this
    * @task parse
    */
   public function parseWorkflows(array $workflows) {
     try {
       return $this->parseWorkflowsFull($workflows);
     } catch (PhutilArgumentUsageException $ex) {
       $this->printUsageException($ex);
       exit(self::PARSE_ERROR_CODE);
     }
   }
 
 
   /**
    * Select a workflow. For commands that may operate in several modes, like
    * `arc`, the modes can be split into "workflows". Each workflow specifies
    * the arguments it accepts. This method takes a list of workflows, selects
    * the chosen workflow, parses its arguments, and either executes it (if it
    * is executable) or returns it for handling.
    *
    * See @{class:PhutilArgumentWorkflow} for details on using workflows.
    *
    * @param list List of @{class:PhutilArgumentWorkflow}s.
    * @return PhutilArgumentWorkflow|no  Returns the chosen workflow if it is
    *                                    not executable, or executes it and
    *                                    exits with a return code if it is.
    * @task parse
    */
   public function parseWorkflowsFull(array $workflows) {
     assert_instances_of($workflows, 'PhutilArgumentWorkflow');
 
     // Clear out existing workflows. We need to do this to permit the
     // construction of sub-workflows.
     $this->workflows = array();
 
     foreach ($workflows as $workflow) {
       $name = $workflow->getName();
 
       if ($name === null) {
         throw new PhutilArgumentSpecificationException(
           pht('Workflow has no name!'));
       }
 
       if (isset($this->workflows[$name])) {
         throw new PhutilArgumentSpecificationException(
           pht("Two workflows with name '%s!", $name));
       }
 
       $this->workflows[$name] = $workflow;
     }
 
     $argv = $this->argv;
     if (empty($argv)) {
       // TODO: this is kind of hacky / magical.
       if (isset($this->workflows['help'])) {
         $argv = array('help');
       } else {
         throw new PhutilArgumentUsageException(pht('No workflow selected.'));
       }
     }
 
     $flow = array_shift($argv);
 
     if (empty($this->workflows[$flow])) {
       $corrected = PhutilArgumentSpellingCorrector::newCommandCorrector()
         ->correctSpelling($flow, array_keys($this->workflows));
 
       $should_autocorrect = $this->shouldAutocorrect();
       if (count($corrected) == 1 && $should_autocorrect) {
         $corrected = head($corrected);
 
         $this->logMessage(
           tsprintf(
             "%s\n",
             pht(
               '(Assuming "%s" is the British spelling of "%s".)',
               $flow,
               $corrected)));
 
         $flow = $corrected;
       } else {
         if (!$this->showHelp) {
           $this->raiseUnknownWorkflow($flow, $corrected);
         }
       }
     }
 
     $workflow = idx($this->workflows, $flow);
 
     if ($this->showHelp) {
       // Make "cmd flow --help" behave like "cmd help flow", not "cmd help".
       $help_flow = idx($this->workflows, 'help');
       if ($help_flow) {
         if ($help_flow !== $workflow) {
           $workflow = $help_flow;
           $argv = array($flow);
 
           // Prevent parse() from dumping us back out to standard help.
           $this->showHelp = false;
         }
       } else {
         $this->printHelpAndExit();
       }
     }
 
     if (!$workflow) {
       $this->raiseUnknownWorkflow($flow, $corrected);
     }
 
     $this->argv = array_values($argv);
 
     if ($workflow->shouldParsePartial()) {
       $this->parsePartial($workflow->getArguments());
     } else {
       $this->parse($workflow->getArguments());
     }
 
 
     if ($workflow->isExecutable()) {
       $workflow->setArgv($this);
       $err = $workflow->execute($this);
       exit($err);
     } else {
       return $workflow;
     }
   }
 
 
   /**
    * Parse "standard" arguments and apply their effects:
    *
    *    --trace             Enable service call tracing.
    *    --no-ansi           Disable ANSI color/style sequences.
    *    --xprofile <file>   Write out an XHProf profile.
    *    --help              Show help.
    *
    * @return this
    *
    * @phutil-external-symbol function xhprof_enable
    */
   public function parseStandardArguments() {
     try {
       $this->parsePartial(
         array(
           array(
             'name'  => 'trace',
             'help'  => pht('Trace command execution and show service calls.'),
             'standard' => true,
           ),
           array(
             'name'  => 'no-ansi',
             'help'  => pht(
               'Disable ANSI terminal codes, printing plain text with '.
               'no color or style.'),
             'conflicts' => array(
               'ansi' => null,
             ),
             'standard' => true,
           ),
           array(
             'name'  => 'ansi',
             'help'  => pht(
               "Use formatting even in environments which probably ".
               "don't support it."),
             'standard' => true,
           ),
           array(
             'name'  => 'xprofile',
             'param' => 'profile',
             'help'  => pht(
               'Profile script execution and write results to a file.'),
             'standard' => true,
           ),
           array(
             'name'  => 'help',
             'short' => 'h',
             'help'  => pht('Show this help.'),
             'standard' => true,
           ),
           array(
             'name'  => 'show-standard-options',
             'help'  => pht(
               'Show every option, including standard options like this one.'),
             'standard' => true,
           ),
           array(
             'name'  => 'recon',
             'help'  => pht('Start in remote console mode.'),
             'standard' => true,
           ),
         ));
     } catch (PhutilArgumentUsageException $ex) {
       $this->printUsageException($ex);
       exit(self::PARSE_ERROR_CODE);
     }
 
     if ($this->getArg('trace')) {
       PhutilServiceProfiler::installEchoListener();
       self::$traceModeEnabled = true;
     }
 
     if ($this->getArg('no-ansi')) {
       PhutilConsoleFormatter::disableANSI(true);
     }
 
     if ($this->getArg('ansi')) {
       PhutilConsoleFormatter::disableANSI(false);
     }
 
     if ($this->getArg('help')) {
       $this->showHelp = true;
     }
 
     $xprofile = $this->getArg('xprofile');
     if ($xprofile) {
       if (!function_exists('xhprof_enable')) {
         throw new Exception(
           pht('To use "--xprofile", you must install XHProf.'));
       }
 
       xhprof_enable(0);
       register_shutdown_function(array($this, 'shutdownProfiler'));
     }
 
     $recon = $this->getArg('recon');
     if ($recon) {
       $remote_console = PhutilConsole::newRemoteConsole();
       $remote_console->beginRedirectOut();
       PhutilConsole::setConsole($remote_console);
     } else if ($this->getArg('trace')) {
       $server = new PhutilConsoleServer();
       $server->setEnableLog(true);
       $console = PhutilConsole::newConsoleForServer($server);
       PhutilConsole::setConsole($console);
     }
 
     return $this;
   }
 
 
 /* -(  Reading Arguments  )-------------------------------------------------- */
 
 
   public function getArg($name) {
     if (empty($this->specs[$name])) {
       throw new PhutilArgumentSpecificationException(
         pht('No specification exists for argument "%s"!', $name));
     }
 
     if (idx($this->results, $name) !== null) {
       return $this->results[$name];
     }
 
     return $this->specs[$name]->getDefault();
   }
 
+  public function getArgAsInteger($name) {
+    $value = $this->getArg($name);
+
+    if ($value === null) {
+      return $value;
+    }
+
+    if (!preg_match('/^-?\d+\z/', $value)) {
+      throw new PhutilArgumentUsageException(
+        pht(
+          'Parameter provided to argument "--%s" must be an integer.',
+          $name));
+    }
+
+    $intvalue = (int)$value;
+
+    if (phutil_string_cast($intvalue) !== phutil_string_cast($value)) {
+      throw new PhutilArgumentUsageException(
+        pht(
+          'Parameter provided to argument "--%s" is too large to '.
+          'parse as an integer.',
+          $name));
+    }
+
+    return $intvalue;
+  }
+
   public function getUnconsumedArgumentVector() {
     return $this->argv;
   }
 
   public function setUnconsumedArgumentVector(array $argv) {
     $this->argv = $argv;
     return $this;
   }
 
   public function setWorkflows($workflows) {
     $workflows = mpull($workflows, null, 'getName');
     $this->workflows = $workflows;
     return $this;
   }
 
   public function setHelpWorkflows(array $help_workflows) {
     $help_workflows = mpull($help_workflows, null, 'getName');
     $this->helpWorkflows = $help_workflows;
     return $this;
   }
 
   public function getWorkflows() {
     return $this->workflows;
   }
 
 
 /* -(  Command Help  )------------------------------------------------------- */
 
   public function setRequireArgumentTerminator($require) {
     $this->requireArgumentTerminator = $require;
     return $this;
   }
 
   public function getRequireArgumentTerminator() {
     return $this->requireArgumentTerminator;
   }
 
   public function setSynopsis($synopsis) {
     $this->synopsis = $synopsis;
     return $this;
   }
 
   public function setTagline($tagline) {
     $this->tagline = $tagline;
     return $this;
   }
 
   public function printHelpAndExit() {
     echo $this->renderHelp();
     exit(self::PARSE_ERROR_CODE);
   }
 
   public function renderHelp() {
     $out = array();
     $more = array();
 
     if ($this->bin) {
       $out[] = $this->format('**%s**', pht('NAME'));
       $name = $this->indent(6, '**%s**', basename($this->bin));
       if ($this->tagline) {
         $name .= $this->format(' - '.$this->tagline);
       }
       $out[] = $name;
       $out[] = null;
     }
 
     if ($this->synopsis) {
       $out[] = $this->format('**%s**', pht('SYNOPSIS'));
       $out[] = $this->indent(6, $this->synopsis);
       $out[] = null;
     }
 
     $workflows = $this->helpWorkflows;
     if ($workflows === null) {
       $workflows = $this->workflows;
     }
 
     if ($workflows) {
       $has_help = false;
       $out[] = $this->format('**%s**', pht('WORKFLOWS'));
       $out[] = null;
       $flows = $workflows;
       ksort($flows);
       foreach ($flows as $workflow) {
         if ($workflow->getName() == 'help') {
           $has_help = true;
         }
         $out[] = $this->renderWorkflowHelp(
           $workflow->getName(),
           $show_details = false);
       }
       if ($has_help) {
         $more[] = pht(
           'Use **%s** __command__ for a detailed command reference.', 'help');
       }
     }
 
     $specs = $this->renderArgumentSpecs($this->specs);
     if ($specs) {
       $out[] = $this->format('**%s**', pht('OPTION REFERENCE'));
       $out[] = null;
       $out[] = $specs;
     }
 
     // If we have standard options but no --show-standard-options, print out
     // a quick hint about it.
     if (!empty($this->specs['show-standard-options']) &&
         !$this->getArg('show-standard-options')) {
       $more[] = pht(
         'Use __%s__ to show additional options.', '--show-standard-options');
     }
 
     $out[] = null;
 
     if ($more) {
       foreach ($more as $hint) {
         $out[] = $this->indent(0, $hint);
       }
       $out[] = null;
     }
 
     return implode("\n", $out);
   }
 
   public function renderWorkflowHelp(
     $workflow_name,
     $show_details = false) {
 
     $out = array();
 
     $indent = ($show_details ? 0 : 6);
 
     $workflows = $this->helpWorkflows;
     if ($workflows === null) {
       $workflows = $this->workflows;
     }
 
     $workflow = idx($workflows, strtolower($workflow_name));
     if (!$workflow) {
       $out[] = $this->indent(
         $indent,
         pht('There is no **%s** workflow.', $workflow_name));
     } else {
       $out[] = $this->indent($indent, $workflow->getExamples());
 
       $synopsis = $workflow->getSynopsis();
       if ($synopsis !== null) {
         $out[] = $this->indent($indent, $workflow->getSynopsis());
       }
 
       if ($show_details) {
         $full_help = $workflow->getHelp();
         if ($full_help) {
           $out[] = null;
           $out[] = $this->indent($indent, $full_help);
         }
         $specs = $this->renderArgumentSpecs($workflow->getArguments());
         if ($specs) {
           $out[] = null;
           $out[] = $specs;
         }
       }
     }
 
     $out[] = null;
 
     return implode("\n", $out);
   }
 
   public function printUsageException(PhutilArgumentUsageException $ex) {
     $message = tsprintf(
       "**%s** %B\n",
       pht('Usage Exception:'),
       $ex->getMessage());
 
     $this->logMessage($message);
   }
 
 
   private function logMessage($message) {
-    fwrite(STDERR, $message);
+    PhutilSystem::writeStderr($message);
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   private function filterWildcardArgv(array $argv) {
     foreach ($argv as $key => $value) {
       if ($value == '--') {
         unset($argv[$key]);
         break;
       } else if (
         is_string($value) &&
         !strncmp($value, '-', 1) &&
         strlen($value) > 1) {
 
         throw new PhutilArgumentUsageException(
           pht(
             'Argument "%s" is unrecognized. Use "%s" to indicate '.
             'the end of flags.',
             $value,
             '--'));
       }
     }
     return array_values($argv);
   }
 
   private function mergeSpecs(array $specs) {
 
     $short_map = mpull($this->specs, null, 'getShortAlias');
     unset($short_map[null]);
 
     $wildcard = null;
     foreach ($this->specs as $spec) {
       if ($spec->getWildcard()) {
         $wildcard = $spec;
         break;
       }
     }
 
     foreach ($specs as $spec) {
       $spec->validate();
       $name = $spec->getName();
 
       if (isset($this->specs[$name])) {
         throw new PhutilArgumentSpecificationException(
           pht(
             'Two argument specifications have the same name ("%s").',
             $name));
       }
 
       $short = $spec->getShortAlias();
       if ($short) {
         if (isset($short_map[$short])) {
           throw new PhutilArgumentSpecificationException(
             pht(
               'Two argument specifications have the same short alias ("%s").',
               $short));
         }
         $short_map[$short] = $spec;
       }
 
       if ($spec->getWildcard()) {
         if ($wildcard) {
           throw new PhutilArgumentSpecificationException(
             pht(
               'Two argument specifications are marked as wildcard arguments. '.
               'You can have a maximum of one wildcard argument.'));
         } else {
           $wildcard = $spec;
         }
       }
 
       $this->specs[$name] = $spec;
     }
 
     foreach ($this->specs as $name => $spec) {
       foreach ($spec->getConflicts() as $conflict => $reason) {
         if (empty($this->specs[$conflict])) {
           throw new PhutilArgumentSpecificationException(
             pht(
               'Argument "%s" conflicts with unspecified argument "%s".',
               $name,
               $conflict));
         }
         if ($conflict == $name) {
           throw new PhutilArgumentSpecificationException(
             pht(
               'Argument "%s" conflicts with itself!',
               $name));
         }
       }
     }
 
   }
 
   private function renderArgumentSpecs(array $specs) {
     foreach ($specs as $key => $spec) {
       if ($spec->getWildcard()) {
         unset($specs[$key]);
       }
     }
 
     $out = array();
 
     $no_standard_options =
       !empty($this->specs['show-standard-options']) &&
       !$this->getArg('show-standard-options');
 
     $specs = msort($specs, 'getName');
     foreach ($specs as $spec) {
       if ($spec->getStandard() && $no_standard_options) {
         // If this is a standard argument and the user didn't pass
         // --show-standard-options, skip it.
         continue;
       }
       $name = $this->indent(6, '__--%s__', $spec->getName());
       $short = null;
       if ($spec->getShortAlias()) {
         $short = $this->format(', __-%s__', $spec->getShortAlias());
       }
       if ($spec->getParamName()) {
         $param = $this->format(' __%s__', $spec->getParamName());
         $name .= $param;
         if ($short) {
           $short .= $param;
         }
       }
       $out[] = $name.$short;
       $out[] = $this->indent(10, $spec->getHelp());
       $out[] = null;
     }
 
     return implode("\n", $out);
   }
 
   private function format($str /* , ... */) {
     $args = func_get_args();
     return call_user_func_array(
       'phutil_console_format',
       $args);
   }
 
   private function indent($level, $str /* , ... */) {
     $args = func_get_args();
     $args = array_slice($args, 1);
     $text = call_user_func_array(array($this, 'format'), $args);
     return phutil_console_wrap($text, $level);
   }
 
   /**
    * @phutil-external-symbol function xhprof_disable
    */
   public function shutdownProfiler() {
     $data = xhprof_disable();
     $data = json_encode($data);
     Filesystem::writeFile($this->getArg('xprofile'), $data);
   }
 
   public static function isTraceModeEnabled() {
     return self::$traceModeEnabled;
   }
 
   private function raiseUnknownWorkflow($flow, array $maybe) {
     if ($maybe) {
       sort($maybe);
 
       $maybe_list = id(new PhutilConsoleList())
         ->setWrap(false)
         ->setBullet(null)
         ->addItems($maybe)
         ->drawConsoleString();
 
       $message = tsprintf(
         "%B\n%B",
         pht(
           'Invalid command "%s". Did you mean:',
           $flow),
         $maybe_list);
     } else {
       $names = mpull($this->workflows, 'getName');
       sort($names);
 
       $message = tsprintf(
         '%B',
         pht(
           'Invalid command "%s". Valid commands are: %s.',
           $flow,
           implode(', ', $names)));
     }
 
     if (isset($this->workflows['help'])) {
       $binary = basename($this->bin);
       $message = tsprintf(
         "%B\n%s",
         $message,
         pht(
           'For details on available commands, run "%s".',
           "{$binary} help"));
     }
 
     throw new PhutilArgumentUsageException($message);
   }
 
   private function shouldAutocorrect() {
     return !phutil_is_noninteractive();
   }
 
 }
diff --git a/src/platform/PlatformSymbols.php b/src/platform/PlatformSymbols.php
new file mode 100644
index 00000000..7533f06b
--- /dev/null
+++ b/src/platform/PlatformSymbols.php
@@ -0,0 +1,21 @@
+<?php
+
+final class PlatformSymbols
+  extends Phobject {
+
+  public static function getPlatformClientName() {
+    return 'Arcanist';
+  }
+
+  public static function getPlatformServerName() {
+    return 'Phabricator';
+  }
+
+  public static function getProductNames() {
+    return array(
+      self::getPlatformClientName(),
+      self::getPlatformServerName(),
+    );
+  }
+
+}
diff --git a/src/progress/PhutilConsoleProgressSink.php b/src/progress/PhutilConsoleProgressSink.php
index 11a61895..ca5dff88 100644
--- a/src/progress/PhutilConsoleProgressSink.php
+++ b/src/progress/PhutilConsoleProgressSink.php
@@ -1,115 +1,115 @@
 <?php
 
 final class PhutilConsoleProgressSink
   extends PhutilProgressSink {
 
   private $lastUpdate;
   private $isTTY;
   private $width;
   private $lineWidth;
 
   protected function publishProgress() {
     if (!$this->shouldPublishToConsole()) {
       return;
     }
 
     $completed = $this->getCompletedWork();
     $total = $this->getTotalWork();
 
     if ($total !== null) {
       $percent = ($completed / $total);
       $percent = min(1, $percent);
       $percent = max(0, $percent);
     } else {
       $percent = null;
     }
 
     // TODO: In TTY mode, draw a nice ASCII progress bar.
 
     if ($percent !== null) {
       $marker = sprintf('% 3.1f%%', 100 * $percent);
     } else {
       $marker = sprintf('% 16d', $completed);
     }
 
     $message = pht('[%s] Working...', $marker);
 
     if ($this->isTTY()) {
       $this->overwriteLine($message);
     } else {
       $this->printLine($message."\n");
     }
 
     $this->didPublishToConsole();
   }
 
   protected function publishCompletion() {
     $this->printLine("\n");
   }
 
   protected function publishFailure() {
     $this->printLine("\n");
   }
 
   private function shouldPublishToConsole() {
     if (!$this->lastUpdate) {
       return true;
     }
 
     // Limit the number of times per second we actually write to the console.
     if ($this->isTTY()) {
       $writes_per_second = 5;
     } else {
       $writes_per_second = 0.5;
     }
 
     $now = microtime(true);
     if (($now - $this->lastUpdate) < (1.0 / $writes_per_second)) {
       return false;
     }
 
     return true;
   }
 
   private function didPublishToConsole() {
     $this->lastUpdate = microtime(true);
   }
 
   private function isTTY() {
     if ($this->isTTY === null) {
       $this->isTTY = (function_exists('posix_isatty') && posix_isatty(STDERR));
     }
     return $this->isTTY;
   }
 
   private function getWidth() {
     if ($this->width === null) {
       $width = phutil_console_get_terminal_width();
       $width = min(nonempty($width, 78), 78);
       $this->width = $width;
     }
 
     return $this->width;
   }
 
   private function overwriteLine($line) {
     $head = "\r";
     $tail = '';
 
     if ($this->lineWidth) {
       $line_len = strlen($line);
 
       if ($line_len < $this->lineWidth) {
         $tail = str_repeat(' ', $this->lineWidth - $line_len);
       }
 
       $this->lineWidth = strlen($line);
     }
 
     $this->printLine($head.$line.$tail);
   }
 
   private function printLine($line) {
-    fprintf(STDERR, '%s', $line);
+    PhutilSystem::writeStderr($line);
   }
 }
diff --git a/src/repository/marker/ArcanistRepositoryMarkerQuery.php b/src/repository/marker/ArcanistRepositoryMarkerQuery.php
index e72ea78f..74e1cdf8 100644
--- a/src/repository/marker/ArcanistRepositoryMarkerQuery.php
+++ b/src/repository/marker/ArcanistRepositoryMarkerQuery.php
@@ -1,121 +1,123 @@
 <?php
 
 abstract class ArcanistRepositoryMarkerQuery
   extends ArcanistRepositoryQuery {
 
   private $isActive;
   private $markerTypes;
   private $names;
   private $commitHashes;
   private $ancestorCommitHashes;
   private $remotes;
   private $isRemoteCache = false;
 
   final public function withMarkerTypes(array $types) {
     $this->markerTypes = array_fuse($types);
     return $this;
   }
 
   final public function withNames(array $names) {
     $this->names = array_fuse($names);
     return $this;
   }
 
   final public function withRemotes(array $remotes) {
     assert_instances_of($remotes, 'ArcanistRemoteRef');
     $this->remotes = $remotes;
     return $this;
   }
 
   final public function withIsRemoteCache($is_cache) {
     $this->isRemoteCache = $is_cache;
     return $this;
   }
 
   final public function withIsActive($active) {
     $this->isActive = $active;
     return $this;
   }
 
   final public function execute() {
     $remotes = $this->remotes;
     if ($remotes !== null) {
       $marker_lists = array();
       foreach ($remotes as $remote) {
         $marker_list = $this->newRemoteRefMarkers($remote);
         foreach ($marker_list as $marker) {
           $marker->attachRemoteRef($remote);
         }
         $marker_lists[] = $marker_list;
       }
       $markers = array_mergev($marker_lists);
     } else {
       $markers = $this->newLocalRefMarkers();
       foreach ($markers as $marker) {
         $marker->attachRemoteRef(null);
       }
     }
 
     $api = $this->getRepositoryAPI();
     foreach ($markers as $marker) {
       $state_ref = id(new ArcanistWorkingCopyStateRef())
         ->setCommitRef($marker->getCommitRef());
 
       $marker->attachWorkingCopyStateRef($state_ref);
 
       $hash = $marker->getCommitHash();
-      $hash = $api->getDisplayHash($hash);
-      $marker->setDisplayHash($hash);
+      if ($hash !== null) {
+        $hash = $api->getDisplayHash($hash);
+        $marker->setDisplayHash($hash);
+      }
     }
 
     $types = $this->markerTypes;
     if ($types !== null) {
       foreach ($markers as $key => $marker) {
         if (!isset($types[$marker->getMarkerType()])) {
           unset($markers[$key]);
         }
       }
     }
 
     $names = $this->names;
     if ($names !== null) {
       foreach ($markers as $key => $marker) {
         if (!isset($names[$marker->getName()])) {
           unset($markers[$key]);
         }
       }
     }
 
     if ($this->isActive !== null) {
       foreach ($markers as $key => $marker) {
         if ($marker->getIsActive() !== $this->isActive) {
           unset($markers[$key]);
         }
       }
     }
 
     if ($this->isRemoteCache !== null) {
       $want_cache = $this->isRemoteCache;
       foreach ($markers as $key => $marker) {
         $is_cache = ($marker->getRemoteName() !== null);
         if ($is_cache !== $want_cache) {
           unset($markers[$key]);
         }
       }
     }
 
     return $markers;
   }
 
   final protected function shouldQueryMarkerType($marker_type) {
     if ($this->markerTypes === null) {
       return true;
     }
 
     return isset($this->markerTypes[$marker_type]);
   }
 
   abstract protected function newLocalRefMarkers();
   abstract protected function newRemoteRefMarkers(ArcanistRemoteRef $remote);
 
 }
diff --git a/src/runtime/ArcanistRuntime.php b/src/runtime/ArcanistRuntime.php
index 35099b2c..8e3d220f 100644
--- a/src/runtime/ArcanistRuntime.php
+++ b/src/runtime/ArcanistRuntime.php
@@ -1,914 +1,914 @@
 <?php
 
 final class ArcanistRuntime {
 
   private $workflows;
   private $logEngine;
   private $lastInterruptTime;
 
   private $stack = array();
 
   private $viewer;
   private $toolset;
   private $hardpointEngine;
   private $symbolEngine;
   private $conduitEngine;
   private $workingCopy;
 
   public function execute(array $argv) {
 
     try {
       $this->checkEnvironment();
     } catch (Exception $ex) {
       echo "CONFIGURATION ERROR\n\n";
       echo $ex->getMessage();
       echo "\n\n";
       return 1;
     }
 
     PhutilTranslator::getInstance()
       ->setLocale(PhutilLocale::loadLocale('en_US'))
       ->setTranslations(PhutilTranslation::getTranslationMapForLocale('en_US'));
 
     $log = new ArcanistLogEngine();
     $this->logEngine = $log;
 
     try {
       return $this->executeCore($argv);
     } catch (ArcanistConduitException $ex) {
       $log->writeError(pht('CONDUIT'), $ex->getMessage());
     } catch (PhutilArgumentUsageException $ex) {
       $log->writeError(pht('USAGE EXCEPTION'), $ex->getMessage());
     } catch (ArcanistUserAbortException $ex) {
       $log->writeError(pht('---'), $ex->getMessage());
     } catch (ArcanistConduitAuthenticationException $ex) {
       $log->writeError($ex->getTitle(), $ex->getBody());
     }
 
     return 1;
   }
 
   private function executeCore(array $argv) {
     $log = $this->getLogEngine();
 
     $config_args = array(
       array(
         'name' => 'library',
         'param' => 'path',
         'help' => pht('Load a library.'),
         'repeat' => true,
       ),
       array(
         'name' => 'config',
         'param' => 'key=value',
         'repeat' => true,
         'help' => pht('Specify a runtime configuration value.'),
       ),
       array(
         'name' => 'config-file',
         'param' => 'path',
         'repeat' => true,
         'help' => pht(
           'Load one or more configuration files. If this flag is provided, '.
           'the system and user configuration files are ignored.'),
       ),
     );
 
     $args = id(new PhutilArgumentParser($argv))
       ->parseStandardArguments();
 
     // If we can test whether STDIN is a TTY, and it isn't, require that "--"
     // appear in the argument list. This is intended to make it very hard to
     // write unsafe scripts on top of Arcanist.
 
     if (phutil_is_noninteractive()) {
       $args->setRequireArgumentTerminator(true);
     }
 
     $is_trace = $args->getArg('trace');
     $log->setShowTraceMessages($is_trace);
 
     $log->writeTrace(pht('ARGV'), csprintf('%Ls', $argv));
 
     // We're installing the signal handler after parsing "--trace" so that it
     // can emit debugging messages. This means there's a very small window at
     // startup where signals have no special handling, but we couldn't really
     // route them or do anything interesting with them anyway.
     $this->installSignalHandler();
 
     $args->parsePartial($config_args, true);
 
     $config_engine = $this->loadConfiguration($args);
     $config = $config_engine->newConfigurationSourceList();
 
     $this->loadLibraries($config_engine, $config, $args);
 
     // Now that we've loaded libraries, we can validate configuration.
     // Do this before continuing since configuration can impact other
     // behaviors immediately and we want to catch any issues right away.
     $config->setConfigOptions($config_engine->newConfigOptionsMap());
     $config->validateConfiguration($this);
 
     $toolset = $this->newToolset($argv);
     $this->setToolset($toolset);
 
     $args->parsePartial($toolset->getToolsetArguments());
 
     $workflows = $this->newWorkflows($toolset);
     $this->workflows = $workflows;
 
     $conduit_engine = $this->newConduitEngine($config, $args);
     $this->conduitEngine = $conduit_engine;
 
     $phutil_workflows = array();
     foreach ($workflows as $key => $workflow) {
       $workflow
         ->setRuntime($this)
         ->setConfigurationEngine($config_engine)
         ->setConfigurationSourceList($config)
         ->setConduitEngine($conduit_engine);
 
       $phutil_workflows[$key] = $workflow->newPhutilWorkflow();
     }
 
 
     $unconsumed_argv = $args->getUnconsumedArgumentVector();
 
     if (!$unconsumed_argv) {
       // TOOLSETS: This means the user just ran "arc" or some other top-level
       // toolset without any workflow argument. We should give them a summary
       // of the toolset, a list of workflows, and a pointer to "arc help" for
       // more details.
 
       // A possible exception is "arc --help", which should perhaps pass
       // through and act like "arc help".
       throw new PhutilArgumentUsageException(pht('Choose a workflow!'));
     }
 
     $alias_effects = id(new ArcanistAliasEngine())
       ->setRuntime($this)
       ->setToolset($toolset)
       ->setWorkflows($workflows)
       ->setConfigurationSourceList($config)
       ->resolveAliases($unconsumed_argv);
 
     foreach ($alias_effects as $alias_effect) {
       if ($alias_effect->getType() === ArcanistAliasEffect::EFFECT_SHELL) {
         return $this->executeShellAlias($alias_effect);
       }
     }
 
     $result_argv = $this->applyAliasEffects($alias_effects, $unconsumed_argv);
 
     $args->setUnconsumedArgumentVector($result_argv);
 
     // TOOLSETS: Some day, stop falling through to the old "arc" runtime.
 
     $help_workflows = $this->getHelpWorkflows($phutil_workflows);
     $args->setHelpWorkflows($help_workflows);
 
     try {
       return $args->parseWorkflowsFull($phutil_workflows);
     } catch (ArcanistMissingArgumentTerminatorException $terminator_exception) {
       $log->writeHint(
         pht('USAGE'),
         pht(
           '"%s" is being run noninteractively, but the argument list is '.
           'missing "--" to indicate end of flags.',
           $toolset->getToolsetKey()));
 
       $log->writeHint(
         pht('USAGE'),
         pht(
           'When running noninteractively, you MUST provide "--" to all '.
           'commands (even if they take no arguments).'));
 
       $log->writeHint(
         pht('USAGE'),
         tsprintf(
           '%s <__%s__>',
           pht('Learn More:'),
           'https://phurl.io/u/noninteractive'));
 
       throw new PhutilArgumentUsageException(
         pht('Missing required "--" in argument list.'));
     } catch (PhutilArgumentUsageException $usage_exception) {
 
       // TODO: This is very, very hacky; we're trying to let errors like
       // "you passed the wrong arguments" through but fall back to classic
       // mode if the workflow itself doesn't exist.
       if (!preg_match('/invalid command/i', $usage_exception->getMessage())) {
         throw $usage_exception;
       }
 
     }
 
     $arcanist_root = phutil_get_library_root('arcanist');
     $arcanist_root = dirname($arcanist_root);
     $bin = $arcanist_root.'/scripts/arcanist.php';
 
     $err = phutil_passthru(
       'php -f %R -- %Ls',
       $bin,
       array_slice($argv, 1));
 
     return $err;
   }
 
 
   /**
    * Perform some sanity checks against the possible diversity of PHP builds in
    * the wild, like very old versions and builds that were compiled with flags
    * that exclude core functionality.
    */
   private function checkEnvironment() {
     // NOTE: We don't have phutil_is_windows() yet here.
     $is_windows = (DIRECTORY_SEPARATOR != '/');
 
     // NOTE: There's a hard PHP version check earlier, in "init-script.php".
 
     if ($is_windows) {
       $need_functions = array(
         'curl_init' => array('builtin-dll', 'php_curl.dll'),
       );
     } else {
       $need_functions = array(
         'curl_init' => array(
           'text',
           "You need to install the cURL PHP extension, maybe with ".
           "'apt-get install php5-curl' or 'yum install php53-curl' or ".
           "something similar.",
         ),
         'json_decode' => array('flag', '--without-json'),
       );
     }
 
     $problems = array();
 
     $config = null;
     $show_config = false;
     foreach ($need_functions as $fname => $resolution) {
       if (function_exists($fname)) {
         continue;
       }
 
       static $info;
       if ($info === null) {
         ob_start();
         phpinfo(INFO_GENERAL);
         $info = ob_get_clean();
         $matches = null;
         if (preg_match('/^Configure Command =>\s*(.*?)$/m', $info, $matches)) {
           $config = $matches[1];
         }
       }
 
       list($what, $which) = $resolution;
 
       if ($what == 'flag' && strpos($config, $which) !== false) {
         $show_config = true;
         $problems[] = sprintf(
           'The build of PHP you are running was compiled with the configure '.
           'flag "%s", which means it does not support the function "%s()". '.
-          'This function is required for Arcanist to run. Install a standard '.
-          'build of PHP or rebuild it without this flag. You may also be '.
-          'able to build or install the relevant extension separately.',
+          'This function is required for this software to run. Install a '.
+          'standard build of PHP or rebuild it without this flag. You may '.
+          'also be able to build or install the relevant extension separately.',
           $which,
           $fname);
         continue;
       }
 
       if ($what == 'builtin-dll') {
         $problems[] = sprintf(
           'The build of PHP you are running does not have the "%s" extension '.
           'enabled. Edit your php.ini file and uncomment the line which '.
           'reads "extension=%s".',
           $which,
           $which);
         continue;
       }
 
       if ($what == 'text') {
         $problems[] = $which;
         continue;
       }
 
       $problems[] = sprintf(
         'The build of PHP you are running is missing the required function '.
         '"%s()". Rebuild PHP or install the extension which provides "%s()".',
         $fname,
         $fname);
     }
 
     if ($problems) {
       if ($show_config) {
         $problems[] = "PHP was built with this configure command:\n\n{$config}";
       }
       $problems = implode("\n\n", $problems);
 
       throw new Exception($problems);
     }
   }
 
   private function loadConfiguration(PhutilArgumentParser $args) {
     $engine = id(new ArcanistConfigurationEngine())
       ->setArguments($args);
 
     $working_copy = ArcanistWorkingCopy::newFromWorkingDirectory(getcwd());
 
     $engine->setWorkingCopy($working_copy);
 
     $this->workingCopy = $working_copy;
 
     $working_copy
       ->getRepositoryAPI()
       ->setRuntime($this);
 
     return $engine;
   }
 
   private function loadLibraries(
     ArcanistConfigurationEngine $engine,
     ArcanistConfigurationSourceList $config,
     PhutilArgumentParser $args) {
 
     $sources = array();
 
     $cli_libraries = $args->getArg('library');
     if ($cli_libraries) {
       $sources = array();
       foreach ($cli_libraries as $cli_library) {
         $sources[] = array(
           'type' => 'flag',
           'library-source' => $cli_library,
         );
       }
     } else {
       $items = $config->getStorageValueList('load');
       foreach ($items as $item) {
         foreach ($item->getValue() as $library_path) {
           $sources[] = array(
             'type' => 'config',
             'config-source' => $item->getConfigurationSource(),
             'library-source' => $library_path,
           );
         }
       }
     }
 
     foreach ($sources as $spec) {
       $library_source = $spec['library-source'];
 
       switch ($spec['type']) {
         case 'flag':
           $description = pht('runtime --library flag');
           break;
         case 'config':
           $config_source = $spec['config-source'];
           $description = pht(
             'Configuration (%s)',
             $config_source->getSourceDisplayName());
           break;
       }
 
       $this->loadLibrary($engine, $library_source, $description);
     }
   }
 
   private function loadLibrary(
     ArcanistConfigurationEngine $engine,
     $location,
     $description) {
 
     // TODO: This is a legacy system that should be replaced with package
     // management.
 
     $log = $this->getLogEngine();
     $working_copy = $engine->getWorkingCopy();
     if ($working_copy) {
       $working_copy_root = $working_copy->getPath();
       $working_directory = $working_copy->getWorkingDirectory();
     } else {
       $working_copy_root = null;
       $working_directory = getcwd();
     }
 
     // Try to resolve the library location. We look in several places, in
     // order:
     //
     //  1. Inside the working copy. This is for phutil libraries within the
     //     project. For instance "library/src" will resolve to
     //     "./library/src" if it exists.
     //  2. In the same directory as the working copy. This allows you to
     //     check out a library alongside a working copy and reference it.
     //     If we haven't resolved yet, "library/src" will try to resolve to
     //     "../library/src" if it exists.
     //  3. Using normal libphutil resolution rules. Generally, this means
     //     that it checks for libraries next to libphutil, then libraries
     //     in the PHP include_path.
     //
     // Note that absolute paths will just resolve absolutely through rule (1).
 
     $resolved = false;
 
     // Check inside the working copy. This also checks absolute paths, since
     // they'll resolve absolute and just ignore the project root.
     if ($working_copy_root !== null) {
       $resolved_location = Filesystem::resolvePath(
         $location,
         $working_copy_root);
       if (Filesystem::pathExists($resolved_location)) {
         $location = $resolved_location;
         $resolved = true;
       }
 
       // If we didn't find anything, check alongside the working copy.
       if (!$resolved) {
         $resolved_location = Filesystem::resolvePath(
           $location,
           dirname($working_copy_root));
         if (Filesystem::pathExists($resolved_location)) {
           $location = $resolved_location;
           $resolved = true;
         }
       }
     }
 
     // Look beside "arcanist/". This is rule (3) above.
 
     if (!$resolved) {
       $arcanist_root = phutil_get_library_root('arcanist');
       $arcanist_root = dirname(dirname($arcanist_root));
       $resolved_location = Filesystem::resolvePath(
         $location,
         $arcanist_root);
       if (Filesystem::pathExists($resolved_location)) {
         $location = $resolved_location;
         $resolved = true;
       }
     }
 
     $log->writeTrace(
       pht('LOAD'),
       pht('Loading library from "%s"...', $location));
 
     $error = null;
     try {
       phutil_load_library($location);
     } catch (PhutilLibraryConflictException $ex) {
       if ($ex->getLibrary() != 'arcanist') {
         throw $ex;
       }
 
       // NOTE: If you are running `arc` against itself, we ignore the library
       // conflict created by loading the local `arc` library (in the current
       // working directory) and continue without loading it.
 
       // This means we only execute code in the `arcanist/` directory which is
       // associated with the binary you are running, whereas we would normally
       // execute local code.
 
       // This can make `arc` development slightly confusing if your setup is
       // especially bizarre, but it allows `arc` to be used in automation
       // workflows more easily. For some context, see PHI13.
 
       $executing_directory = dirname(dirname(__FILE__));
 
       $log->writeWarn(
         pht('VERY META'),
         pht(
-          'You are running one copy of Arcanist (at path "%s") against '.
-          'another copy of Arcanist (at path "%s"). Code in the current '.
+          'You are running one copy of this software (at path "%s") against '.
+          'another copy of this software (at path "%s"). Code in the current '.
           'working directory will not be loaded or executed.',
           $executing_directory,
           $working_directory));
     } catch (PhutilBootloaderException $ex) {
       $log->writeError(
         pht('LIBRARY ERROR'),
         pht(
           'Failed to load library at location "%s". This library '.
           'is specified by "%s". Check that the library is up to date.',
           $location,
           $description));
 
       $prompt = pht('Continue without loading library?');
       if (!phutil_console_confirm($prompt)) {
         throw $ex;
       }
     } catch (Exception $ex) {
       $log->writeError(
         pht('LOAD ERROR'),
         pht(
           'Failed to load library at location "%s". This library is '.
           'specified by "%s". Check that the setting is correct and the '.
           'library is located in the right place.',
           $location,
           $description));
 
       $prompt = pht('Continue without loading library?');
       if (!phutil_console_confirm($prompt)) {
         throw $ex;
       }
     }
   }
 
   private function newToolset(array $argv) {
     $binary = basename($argv[0]);
 
     $toolsets = ArcanistToolset::newToolsetMap();
     if (!isset($toolsets[$binary])) {
       throw new PhutilArgumentUsageException(
         pht(
-          'Arcanist toolset "%s" is unknown. The Arcanist binary should '.
-          'be executed so that "argv[0]" identifies a supported toolset. '.
-          'Rename the binary or install the library that provides the '.
-          'desired toolset. Current available toolsets: %s.',
+          'Toolset "%s" is unknown. The binary should be executed so that '.
+          '"argv[0]" identifies a supported toolset. Rename the binary or '.
+          'install the library that provides the desired toolset. Current '.
+          'available toolsets: %s.',
           $binary,
           implode(', ', array_keys($toolsets))));
     }
 
     return $toolsets[$binary];
   }
 
   private function newWorkflows(ArcanistToolset $toolset) {
     $workflows = id(new PhutilClassMapQuery())
       ->setAncestorClass('ArcanistWorkflow')
       ->setContinueOnFailure(true)
       ->execute();
 
     foreach ($workflows as $key => $workflow) {
       if (!$workflow->supportsToolset($toolset)) {
         unset($workflows[$key]);
       }
     }
 
     $map = array();
     foreach ($workflows as $workflow) {
       $key = $workflow->getWorkflowName();
       if (isset($map[$key])) {
         throw new Exception(
           pht(
             'Two workflows ("%s" and "%s") both have the same name ("%s") '.
             'and both support the current toolset ("%s", "%s"). Each '.
             'workflow in a given toolset must have a unique name.',
             get_class($workflow),
             get_class($map[$key]),
             $key,
             get_class($toolset),
             $toolset->getToolsetKey()));
       }
       $map[$key] = id(clone $workflow)
         ->setToolset($toolset);
     }
 
     return $map;
   }
 
   public function getWorkflows() {
     return $this->workflows;
   }
 
   public function getLogEngine() {
     return $this->logEngine;
   }
 
   private function applyAliasEffects(array $effects, array $argv) {
     assert_instances_of($effects, 'ArcanistAliasEffect');
 
     $log = $this->getLogEngine();
 
     $command = null;
     $arguments = null;
     foreach ($effects as $effect) {
       $message = $effect->getMessage();
 
       if ($message !== null) {
         $log->writeHint(pht('ALIAS'), $message);
       }
 
       if ($effect->getCommand()) {
         $command = $effect->getCommand();
         $arguments = $effect->getArguments();
       }
     }
 
     if ($command !== null) {
       $argv = array_merge(array($command), $arguments);
     }
 
     return $argv;
   }
 
   private function installSignalHandler() {
     $log = $this->getLogEngine();
 
     if (!function_exists('pcntl_signal')) {
       $log->writeTrace(
         pht('PCNTL'),
         pht(
           'Unable to install signal handler, pcntl_signal() unavailable. '.
           'Continuing without signal handling.'));
       return;
     }
 
     // NOTE: SIGHUP, SIGTERM and SIGWINCH are handled by "PhutilSignalRouter".
     // This logic is largely similar to the logic there, but more specific to
     // Arcanist workflows.
 
     pcntl_signal(SIGINT, array($this, 'routeSignal'));
   }
 
   public function routeSignal($signo) {
     switch ($signo) {
       case SIGINT:
         $this->routeInterruptSignal($signo);
         break;
     }
   }
 
   private function routeInterruptSignal($signo) {
     $log = $this->getLogEngine();
 
     $last_interrupt = $this->lastInterruptTime;
     $now = microtime(true);
     $this->lastInterruptTime = $now;
 
     $should_exit = false;
 
     // If we received another SIGINT recently, always exit. This implements
     // "press ^C twice in quick succession to exit" regardless of what the
     // workflow may decide to do.
     $interval = 2;
     if ($last_interrupt !== null) {
       if ($now - $last_interrupt < $interval) {
         $should_exit = true;
       }
     }
 
     $handler = null;
     if (!$should_exit) {
 
       // Look for an interrupt handler in the current workflow stack.
 
       $stack = $this->getWorkflowStack();
       foreach ($stack as $workflow) {
         if ($workflow->canHandleSignal($signo)) {
           $handler = $workflow;
           break;
         }
       }
 
       // If no workflow in the current execution stack can handle an interrupt
       // signal, just exit on the first interrupt.
 
       if (!$handler) {
         $should_exit = true;
       }
     }
 
     // It's common for users to ^C on prompts. Write a newline before writing
     // a response to the interrupt so the behavior is a little cleaner. This
     // also avoids lines that read "^C [ INTERRUPT ] ...".
     $log->writeNewline();
 
     if ($should_exit) {
       $log->writeHint(
         pht('INTERRUPT'),
         pht('Interrupted by SIGINT (^C).'));
       exit(128 + $signo);
     }
 
     $log->writeHint(
       pht('INTERRUPT'),
       pht('Press ^C again to exit.'));
 
     $handler->handleSignal($signo);
   }
 
   public function pushWorkflow(ArcanistWorkflow $workflow) {
     $this->stack[] = $workflow;
     return $this;
   }
 
   public function popWorkflow() {
     if (!$this->stack) {
       throw new Exception(pht('Trying to pop an empty workflow stack!'));
     }
 
     return array_pop($this->stack);
   }
 
   public function getWorkflowStack() {
     return $this->stack;
   }
 
   public function getCurrentWorkflow() {
     return last($this->stack);
   }
 
   private function newConduitEngine(
     ArcanistConfigurationSourceList $config,
     PhutilArgumentParser $args) {
 
     try {
       $force_uri = $args->getArg('conduit-uri');
     } catch (PhutilArgumentSpecificationException $ex) {
       $force_uri = null;
     }
 
     try {
       $force_token = $args->getArg('conduit-token');
     } catch (PhutilArgumentSpecificationException $ex) {
       $force_token = null;
     }
 
     if ($force_uri !== null) {
       $conduit_uri = $force_uri;
     } else {
       $conduit_uri = $config->getConfig('phabricator.uri');
       if ($conduit_uri === null) {
         // For now, read this older config from raw storage. There is currently
         // no definition of this option in the "toolsets" config list, and it
         // would be nice to get rid of it.
         $default_list = $config->getStorageValueList('default');
         if ($default_list) {
           $conduit_uri = last($default_list)->getValue();
         }
       }
     }
 
     if ($conduit_uri) {
       // Set the URI path to '/api/'. TODO: Originally, I contemplated letting
       // you deploy Phabricator somewhere other than the domain root, but ended
       // up never pursuing that. We should get rid of all "/api/" silliness
       // in things users are expected to configure. This is already happening
       // to some degree, e.g. "arc install-certificate" does it for you.
       $conduit_uri = new PhutilURI($conduit_uri);
       $conduit_uri->setPath('/api/');
       $conduit_uri = phutil_string_cast($conduit_uri);
     }
 
     $engine = new ArcanistConduitEngine();
 
     if ($conduit_uri !== null) {
       $engine->setConduitURI($conduit_uri);
     }
 
     // TODO: This isn't using "getConfig()" because we aren't defining a
     // real config entry for the moment.
 
     if ($force_token !== null) {
       $conduit_token = $force_token;
     } else {
       $hosts = array();
 
       $hosts_list = $config->getStorageValueList('hosts');
       foreach ($hosts_list as $hosts_config) {
         $hosts += $hosts_config->getValue();
       }
 
       $host_config = idx($hosts, $conduit_uri, array());
       $conduit_token = idx($host_config, 'token');
     }
 
     if ($conduit_token !== null) {
       $engine->setConduitToken($conduit_token);
     }
 
     return $engine;
   }
 
   private function executeShellAlias(ArcanistAliasEffect $effect) {
     $log = $this->getLogEngine();
 
     $message = $effect->getMessage();
     if ($message !== null) {
       $log->writeHint(pht('SHELL ALIAS'), $message);
     }
 
     return phutil_passthru('%Ls', $effect->getArguments());
   }
 
   public function getSymbolEngine() {
     if ($this->symbolEngine === null) {
       $this->symbolEngine = $this->newSymbolEngine();
     }
     return $this->symbolEngine;
   }
 
   private function newSymbolEngine() {
     return id(new ArcanistSymbolEngine())
       ->setWorkflow($this);
   }
 
   public function getHardpointEngine() {
     if ($this->hardpointEngine === null) {
       $this->hardpointEngine = $this->newHardpointEngine();
     }
     return $this->hardpointEngine;
   }
 
   private function newHardpointEngine() {
     $engine = new ArcanistHardpointEngine();
 
     $queries = ArcanistRuntimeHardpointQuery::getAllQueries();
 
     foreach ($queries as $key => $query) {
       $queries[$key] = id(clone $query)
         ->setRuntime($this);
     }
 
     $engine->setQueries($queries);
 
     return $engine;
   }
 
   public function getViewer() {
     if (!$this->viewer) {
       $viewer = $this->getSymbolEngine()
         ->loadUserForSymbol('viewer()');
 
       // TODO: Deal with anonymous stuff.
       if (!$viewer) {
         throw new Exception(pht('No viewer!'));
       }
 
       $this->viewer = $viewer;
     }
 
     return $this->viewer;
   }
 
   public function loadHardpoints($objects, $requests) {
     if (!is_array($objects)) {
       $objects = array($objects);
     }
 
     if (!is_array($requests)) {
       $requests = array($requests);
     }
 
     $engine = $this->getHardpointEngine();
 
     $requests = $engine->requestHardpoints(
       $objects,
       $requests);
 
     // TODO: Wait for only the required requests.
     $engine->waitForRequests(array());
   }
 
   public function getWorkingCopy() {
     return $this->workingCopy;
   }
 
   public function getConduitEngine() {
     return $this->conduitEngine;
   }
 
   public function setToolset($toolset) {
     $this->toolset = $toolset;
     return $this;
   }
 
   public function getToolset() {
     return $this->toolset;
   }
 
   private function getHelpWorkflows(array $workflows) {
     if ($this->getToolset()->getToolsetKey() === 'arc') {
       $legacy = array();
 
       $legacy[] = new ArcanistCloseRevisionWorkflow();
       $legacy[] = new ArcanistCommitWorkflow();
       $legacy[] = new ArcanistCoverWorkflow();
       $legacy[] = new ArcanistDiffWorkflow();
       $legacy[] = new ArcanistExportWorkflow();
       $legacy[] = new ArcanistGetConfigWorkflow();
       $legacy[] = new ArcanistSetConfigWorkflow();
       $legacy[] = new ArcanistInstallCertificateWorkflow();
       $legacy[] = new ArcanistLintersWorkflow();
       $legacy[] = new ArcanistLintWorkflow();
       $legacy[] = new ArcanistListWorkflow();
       $legacy[] = new ArcanistPatchWorkflow();
       $legacy[] = new ArcanistPasteWorkflow();
       $legacy[] = new ArcanistTasksWorkflow();
       $legacy[] = new ArcanistTodoWorkflow();
       $legacy[] = new ArcanistUnitWorkflow();
       $legacy[] = new ArcanistWhichWorkflow();
 
       foreach ($legacy as $workflow) {
         // If this workflow has been updated but not removed from the list
         // above yet, just skip it.
         if ($workflow instanceof ArcanistArcWorkflow) {
           continue;
         }
 
         $workflows[] = $workflow->newLegacyPhutilWorkflow();
       }
     }
 
     return $workflows;
   }
 
 }
diff --git a/src/symbols/PhutilSymbolLoader.php b/src/symbols/PhutilSymbolLoader.php
index 32c7a042..a5851a5e 100644
--- a/src/symbols/PhutilSymbolLoader.php
+++ b/src/symbols/PhutilSymbolLoader.php
@@ -1,455 +1,456 @@
 <?php
 
 /**
  * Query and load Phutil classes, interfaces and functions.
  *
  * `PhutilSymbolLoader` is a query object which selects symbols which satisfy
  * certain criteria, and optionally loads them. For instance, to load all
  * classes in a library:
  *
  * ```lang=php
  * $symbols = id(new PhutilSymbolLoader())
  *   ->setType('class')
  *   ->setLibrary('example')
  *   ->selectAndLoadSymbols();
  * ```
  *
  * When you execute the loading query, it returns a dictionary of matching
  * symbols:
  *
  * ```lang=php
  * array(
  *   'class$Example' => array(
  *     'type'    => 'class',
  *     'name'    => 'Example',
  *     'library' => 'libexample',
  *     'where'   => 'examples/example.php',
  *   ),
  *   // ... more ...
  * );
  * ```
  *
  * The **library** and **where** keys show where the symbol is defined. The
  * **type** and **name** keys identify the symbol itself.
  *
  * NOTE: This class must not use libphutil functions, including @{function:id}
  * and @{function:idx}.
  *
  * @task config   Configuring the Query
  * @task load     Loading Symbols
  * @task internal Internals
  */
 final class PhutilSymbolLoader {
 
   private $type;
   private $library;
   private $base;
   private $name;
   private $concrete;
   private $pathPrefix;
 
   private $suppressLoad;
   private $continueOnFailure;
 
 
   /**
    * Select the type of symbol to load, either `class`, `function` or
    * `interface`.
    *
    * @param string  Type of symbol to load.
    * @return this
    *
    * @task config
    */
   public function setType($type) {
     $this->type = $type;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to a specific library; only symbols from this
    * library will be loaded.
    *
    * @param string Library name.
    * @return this
    *
    * @task config
    */
   public function setLibrary($library) {
     // Validate the library name; this throws if the library in not loaded.
     $bootloader = PhutilBootloader::getInstance();
     $bootloader->getLibraryRoot($library);
 
     $this->library = $library;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to a specific path prefix; only symbols defined
    * in files below that path will be selected.
    *
    * @param string Path relative to library root, like "apps/cheese/".
    * @return this
    *
    * @task config
    */
   public function setPathPrefix($path) {
     $this->pathPrefix = str_replace(DIRECTORY_SEPARATOR, '/', $path);
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to a single symbol name, e.g. a specific class
    * or function name.
    *
    * @param string Symbol name.
    * @return this
    *
    * @task config
    */
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to only descendants of some class. This will
    * strictly select descendants, the base class will not be selected. This
    * implies loading only classes.
    *
    * @param string Base class name.
    * @return this
    *
    * @task config
    */
   public function setAncestorClass($base) {
     $this->base = $base;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to only concrete symbols; this will filter out
    * abstract classes.
    *
    * NOTE: This currently causes class symbols to load, even if you run
    * @{method:selectSymbolsWithoutLoading}.
    *
    * @param bool True if the query should load only concrete symbols.
    * @return this
    *
    * @task config
    */
   public function setConcreteOnly($concrete) {
     $this->concrete = $concrete;
     return $this;
   }
 
   public function setContinueOnFailure($continue) {
     $this->continueOnFailure = $continue;
     return $this;
   }
 
 /* -(  Load  )--------------------------------------------------------------- */
 
 
   /**
    * Execute the query and select matching symbols, then load them so they can
    * be used.
    *
    * @return dict A dictionary of matching symbols. See top-level class
    *              documentation for details. These symbols will be loaded
    *              and available.
    *
    * @task load
    */
   public function selectAndLoadSymbols() {
     $map = array();
 
     $bootloader = PhutilBootloader::getInstance();
 
     if ($this->library) {
       $libraries = array($this->library);
     } else {
       $libraries = $bootloader->getAllLibraries();
     }
 
     if ($this->type) {
       $types = array($this->type);
     } else {
       $types = array(
         'class',
         'function',
       );
     }
 
     $names = null;
     if ($this->base) {
       $names = $this->selectDescendantsOf(
         $bootloader->getClassTree(),
         $this->base);
     }
 
     $symbols = array();
     foreach ($libraries as $library) {
       $map = $bootloader->getLibraryMap($library);
       foreach ($types as $type) {
         if ($type == 'interface') {
           $lookup_map = $map['class'];
         } else {
           $lookup_map = $map[$type];
         }
 
         // As an optimization, we filter the list of candidate symbols in
         // several passes, applying a name-based filter first if possible since
         // it is highly selective and guaranteed to match at most one symbol.
         // This is the common case and we land here through `__autoload()` so
         // it's worthwhile to micro-optimize a bit because this code path is
         // very hot and we save 5-10ms per page for a very moderate increase in
         // complexity.
 
         if ($this->name) {
           // If we have a name filter, just pick the matching name out if it
           // exists.
           if (isset($lookup_map[$this->name])) {
             $filtered_map = array(
               $this->name => $lookup_map[$this->name],
             );
           } else {
             $filtered_map = array();
           }
         } else if ($names !== null) {
           $filtered_map = array();
           foreach ($names as $name => $ignored) {
             if (isset($lookup_map[$name])) {
               $filtered_map[$name] = $lookup_map[$name];
             }
           }
         } else {
           // Otherwise, start with everything.
           $filtered_map = $lookup_map;
         }
 
         if ($this->pathPrefix) {
           $len = strlen($this->pathPrefix);
           foreach ($filtered_map as $name => $where) {
             if (strncmp($where, $this->pathPrefix, $len) !== 0) {
               unset($filtered_map[$name]);
             }
           }
         }
 
         foreach ($filtered_map as $name => $where) {
           $symbols[$type.'$'.$name] = array(
             'type'        => $type,
             'name'        => $name,
             'library'     => $library,
             'where'       => $where,
           );
         }
       }
     }
 
     if (!$this->suppressLoad) {
       // Loading a class may trigger the autoloader to load more classes
       // (usually, the parent class), so we need to keep track of whether we
       // are currently loading in "continue on failure" mode. Otherwise, we'll
       // fail anyway if we fail to load a parent class.
 
       // The driving use case for the "continue on failure" mode is to let
       // "arc liberate" run so it can rebuild the library map, even if you have
       // made changes to Workflow or Config classes which it must load before
       // it can operate. If we don't let it continue on failure, it is very
       // difficult to remove or move Workflows.
 
       static $continue_depth = 0;
       if ($this->continueOnFailure) {
         $continue_depth++;
       }
 
       $caught = null;
       foreach ($symbols as $key => $symbol) {
         try {
           $this->loadSymbol($symbol);
         } catch (Exception $ex) {
           // If we failed to load this symbol, remove it from the results.
           // Otherwise, we may fatal below when trying to reflect it.
           unset($symbols[$key]);
 
           $caught = $ex;
         }
       }
 
       $should_continue = ($continue_depth > 0);
 
       if ($this->continueOnFailure) {
         $continue_depth--;
       }
 
       if ($caught) {
         // NOTE: We try to load everything even if we fail to load something,
         // primarily to make it possible to remove functions from a libphutil
         // library without breaking library startup.
         if ($should_continue) {
           // We may not have `pht()` yet.
-          fprintf(
-            STDERR,
+          $message = sprintf(
             "%s: %s\n",
             'IGNORING CLASS LOAD FAILURE',
             $caught->getMessage());
+
+          @file_put_contents('php://stderr', $message);
         } else {
           throw $caught;
         }
       }
     }
 
 
     if ($this->concrete) {
       // Remove 'abstract' classes.
       foreach ($symbols as $key => $symbol) {
         if ($symbol['type'] == 'class') {
           $reflection = new ReflectionClass($symbol['name']);
           if ($reflection->isAbstract()) {
             unset($symbols[$key]);
           }
         }
       }
     }
 
     return $symbols;
   }
 
 
   /**
    * Execute the query and select matching symbols, but do not load them. This
    * will perform slightly better if you are only interested in the existence
    * of the symbols and don't plan to use them; otherwise, use
    * @{method:selectAndLoadSymbols}.
    *
    * @return dict A dictionary of matching symbols. See top-level class
    *              documentation for details.
    *
    * @task load
    */
   public function selectSymbolsWithoutLoading() {
     $this->suppressLoad = true;
     $result = $this->selectAndLoadSymbols();
     $this->suppressLoad = false;
     return $result;
   }
 
 
   /**
    * Select symbols matching the query and then instantiate them, returning
    * concrete objects. This is a convenience method which simplifies symbol
    * handling if you are only interested in building objects.
    *
    * If you want to do more than build objects, or want to build objects with
    * varying constructor arguments, use @{method:selectAndLoadSymbols} for
    * fine-grained control over results.
    *
    * This method implicitly restricts the query to match only concrete
    * classes.
    *
    * @param  list<wild>           List of constructor arguments.
    * @return map<string, object>  Map of class names to constructed objects.
    */
   public function loadObjects(array $argv = array()) {
     $symbols = $this
       ->setConcreteOnly(true)
       ->setType('class')
       ->selectAndLoadSymbols();
 
     $objects = array();
     foreach ($symbols as $symbol) {
       $objects[$symbol['name']] = newv($symbol['name'], $argv);
     }
 
     return $objects;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * @task internal
    */
   private function selectDescendantsOf(array $tree, $root) {
     $result = array();
 
     if (empty($tree[$root])) {
       // No known descendants.
       return array();
     }
 
     foreach ($tree[$root] as $child) {
       $result[$child] = true;
       if (!empty($tree[$child])) {
         $result += $this->selectDescendantsOf($tree, $child);
       }
     }
     return $result;
   }
 
 
   /**
    * @task internal
    */
   private function loadSymbol(array $symbol_spec) {
     // Check if we've already loaded the symbol; bail if we have.
     $name = $symbol_spec['name'];
     $is_function = ($symbol_spec['type'] == 'function');
 
     if ($is_function) {
       if (function_exists($name)) {
         return;
       }
     } else {
       if (class_exists($name, false) || interface_exists($name, false)) {
         return;
       }
     }
 
     $lib_name = $symbol_spec['library'];
     $where = $symbol_spec['where'];
     $bootloader = PhutilBootloader::getInstance();
 
     $bootloader->loadLibrarySource($lib_name, $where);
 
     // Check that we successfully loaded the symbol from wherever it was
     // supposed to be defined.
 
     $load_failed = null;
     if ($is_function) {
       if (!function_exists($name)) {
         $load_failed = pht('function');
       }
     } else {
       if (!class_exists($name, false) && !interface_exists($name, false)) {
         $load_failed = pht('class or interface');
       }
     }
 
     if ($load_failed !== null) {
       $lib_path = phutil_get_library_root($lib_name);
       throw new PhutilMissingSymbolException(
         $name,
         $load_failed,
         pht(
           "The symbol map for library '%s' (at '%s') claims this %s is ".
           "defined in '%s', but loading that source file did not cause the ".
           "%s to become defined.",
           $lib_name,
           $lib_path,
           $load_failed,
           $where,
           $load_failed));
     }
   }
 
 }
diff --git a/src/toolset/ArcanistArcToolset.php b/src/toolset/ArcanistArcToolset.php
index 5c1cb377..1778372e 100644
--- a/src/toolset/ArcanistArcToolset.php
+++ b/src/toolset/ArcanistArcToolset.php
@@ -1,22 +1,22 @@
 <?php
 
 final class ArcanistArcToolset extends ArcanistToolset {
 
   const TOOLSETKEY = 'arc';
 
   public function getToolsetArguments() {
     return array(
       array(
         'name' => 'conduit-uri',
         'param' => 'uri',
-        'help' => pht('Connect to Phabricator install specified by __uri__.'),
+        'help' => pht('Connect to server specified by __uri__.'),
       ),
       array(
         'name' => 'conduit-token',
         'param' => 'token',
         'help' => pht('Use a specific authentication token.'),
       ),
     );
   }
 
 }
diff --git a/src/toolset/workflow/ArcanistShellCompleteWorkflow.php b/src/toolset/workflow/ArcanistShellCompleteWorkflow.php
index f68d04a5..9c2fcf9a 100644
--- a/src/toolset/workflow/ArcanistShellCompleteWorkflow.php
+++ b/src/toolset/workflow/ArcanistShellCompleteWorkflow.php
@@ -1,666 +1,666 @@
 <?php
 
 final class ArcanistShellCompleteWorkflow
   extends ArcanistWorkflow {
 
   public function supportsToolset(ArcanistToolset $toolset) {
     return true;
   }
 
   public function getWorkflowName() {
     return 'shell-complete';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 Install shell completion so you can use the "tab" key to autocomplete
-commands and flags in your shell for Arcanist toolsets and workflows.
+commands and flags in your shell for toolsets and workflows.
 
 The **bash** shell is supported.
 
 **Installing Completion**
 
 To install shell completion, run the command:
 
   $ arc shell-complete
 
 This will install shell completion into your current shell. After installing,
 you may need to start a new shell (or open a new terminal window) to pick up
 the updated configuration.
 
-Once installed, completion should work across all Arcanist toolsets.
+Once installed, completion should work across all toolsets.
 
 **Using Completion**
 
 After completion is installed, use the "tab" key to automatically complete
 workflows and flags. For example, if you type:
 
   $ arc diff --draf<tab>
 
 ...your shell should automatically expand the flag to:
 
   $ arc diff --draft
 
 **Updating Completion**
 
 To update shell completion, run the same command:
 
   $ arc shell-complete
 
 You can update shell completion without reinstalling it by running:
 
   $ arc shell-complete --generate
 
 You may need to update shell completion if:
 
-  - you install new Arcanist toolsets; or
-  - you move the Arcanist directory; or
-  - you upgrade Arcanist and the new version fixes shell completion bugs.
+  - you install new toolsets; or
+  - you move this software on disk; or
+  - you upgrade this software and the new version fixes shell completion bugs.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Install shell completion.'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('current')
         ->setParameter('cursor-position')
         ->setHelp(
           pht(
             'Internal. Current term in the argument list being completed.')),
       $this->newWorkflowArgument('generate')
         ->setHelp(
           pht(
             'Regenerate shell completion rules, without installing any '.
             'configuration.')),
       $this->newWorkflowArgument('shell')
         ->setParameter('shell-name')
         ->setHelp(
           pht(
             'Install completion support for a particular shell.')),
       $this->newWorkflowArgument('argv')
         ->setWildcard(true),
     );
   }
 
   public function runWorkflow() {
     $log = $this->getLogEngine();
 
     $argv = $this->getArgument('argv');
 
     $is_generate = $this->getArgument('generate');
     $is_shell = (bool)strlen($this->getArgument('shell'));
     $is_current = $this->getArgument('current');
 
     if ($argv) {
       $should_install = false;
       $should_generate = false;
 
       if ($is_generate) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--generate" when completing arguments.'));
       }
 
       if ($is_shell) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--shell" when completing arguments.'));
       }
 
     } else if ($is_generate) {
       $should_install = false;
       $should_generate = true;
 
       if ($is_current) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--current" when generating rules.'));
       }
 
       if ($is_shell) {
         throw new PhutilArgumentUsageException(
           pht(
             'The flags "--generate" and "--shell" are mutually exclusive. '.
             'The "--shell" flag selects which shell to install support for, '.
             'but the "--generate" suppresses installation.'));
       }
 
     } else {
       $should_install = true;
       $should_generate = true;
 
       if ($is_current) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--current" when installing support.'));
       }
     }
 
     if ($should_install) {
       $this->runInstall();
     }
 
     if ($should_generate) {
       $this->runGenerate();
     }
 
     if ($should_install || $should_generate) {
       $log->writeHint(
         pht('NOTE'),
         pht(
           'You may need to open a new terminal window or launch a new shell '.
           'before the changes take effect.'));
       return 0;
     }
 
     $this->runAutocomplete();
   }
 
   protected function newPrompts() {
     return array(
       $this->newPrompt('arc.shell-complete.install')
         ->setDescription(
           pht(
             'Confirms writing to to "~/.profile" (or another similar file) '.
             'to install shell completion.')),
     );
   }
 
   private function runInstall() {
     $log = $this->getLogEngine();
 
     $shells = array(
       array(
         'key' => 'bash',
         'path' => '/bin/bash',
         'file' => '.profile',
         'source' => 'hooks/bash-completion.sh',
       ),
     );
     $shells = ipull($shells, null, 'key');
 
     $shell = $this->getArgument('shell');
     if (!$shell) {
       $shell = $this->detectShell($shells);
     } else {
       $shell = $this->selectShell($shells, $shell);
     }
 
     $spec = $shells[$shell];
     $file = $spec['file'];
     $home = getenv('HOME');
 
     if (!strlen($home)) {
       throw new PhutilArgumentUsageException(
         pht(
           'The "HOME" environment variable is not defined, so this workflow '.
           'can not identify where to install shell completion.'));
     }
 
     $file_path = getenv('HOME').'/'.$file;
     $file_display = '~/'.$file;
 
     if (Filesystem::pathExists($file_path)) {
       $file_path = Filesystem::resolvePath($file_path);
       $data = Filesystem::readFile($file_path);
       $is_new = false;
     } else {
       $data = '';
       $is_new = true;
     }
 
     $line = csprintf(
       'source %R # arcanist-shell-complete',
       $this->getShellPath($spec['source']));
 
     $matches = null;
     $replace = preg_match(
       '/(\s*\n)?[^\n]+# arcanist-shell-complete\s*(\n\s*)?/',
       $data,
       $matches,
       PREG_OFFSET_CAPTURE);
 
     $log->writeSuccess(
       pht('INSTALL'),
       pht(
         'Installing shell completion support for "%s" into "%s".',
         $shell,
         $file_display));
 
     if ($replace) {
       $replace_pos = $matches[0][1];
       $replace_line = $matches[0][0];
       $replace_len = strlen($replace_line);
       $replace_display = trim($replace_line);
 
       if ($replace_pos === 0) {
         $new_line = $line."\n";
       } else {
         $new_line = "\n\n".$line."\n";
       }
 
       $new_data = substr_replace($data, $new_line, $replace_pos, $replace_len);
 
       if ($new_data === $data) {
         // If we aren't changing anything in the file, just skip the write
         // completely.
         $needs_write = false;
 
         $log->writeStatus(
           pht('SKIP'),
           pht('Shell completion for "%s" is already installed.', $shell));
 
         return;
       }
 
       echo tsprintf(
         "%s\n\n    %s\n\n%s\n\n    %s\n",
         pht(
           'To update shell completion support for "%s", your existing '.
           '"%s" file will be modified. This line will be removed:',
           $shell,
           $file_display),
         $replace_display,
         pht('This line will be added:'),
         $line);
 
       $prompt = pht('Rewrite this file?');
     } else {
       if ($is_new) {
         $new_data = $line."\n";
 
         echo tsprintf(
           "%s\n\n    %s\n",
           pht(
             'To install shell completion support for "%s", a new "%s" file '.
             'will be created with this content:',
             $shell,
             $file_display),
           $line);
 
         $prompt = pht('Create this file?');
       } else {
         $new_data = rtrim($data)."\n\n".$line."\n";
 
         echo tsprintf(
           "%s\n\n     %s\n",
           pht(
             'To install shell completion support for "%s", this line will be '.
             'added to your existing "%s" file:',
             $shell,
             $file_display),
           $line);
 
         $prompt = pht('Append to this file?');
       }
     }
 
     $this->getPrompt('arc.shell-complete.install')
       ->setQuery($prompt)
       ->execute();
 
     Filesystem::writeFile($file_path, $new_data);
 
     $log->writeSuccess(
       pht('INSTALLED'),
       pht(
         'Installed shell completion support for "%s" to "%s".',
         $shell,
         $file_display));
   }
 
   private function selectShell(array $shells, $shell_arg) {
     foreach ($shells as $shell) {
       if ($shell['key'] === $shell_arg) {
         return $shell_arg;
       }
     }
 
     throw new PhutilArgumentUsageException(
       pht(
         'The shell "%s" is not supported. Supported shells are: %s.',
         $shell_arg,
         implode(', ', ipull($shells, 'key'))));
   }
 
   private function detectShell(array $shells) {
     // NOTE: The "BASH_VERSION" and "ZSH_VERSION" shell variables are not
     // passed to subprocesses, so we can't inspect them to figure out which
     // shell launched us. If we could figure this out in some other way, it
     // would be nice to do so.
 
     // Instead, just look at "SHELL" (the user's startup shell).
 
     $log = $this->getLogEngine();
 
     $detected = array();
     $log->writeStatus(
       pht('DETECT'),
       pht('Detecting current shell...'));
 
     $shell_env = getenv('SHELL');
     if (!strlen($shell_env)) {
       $log->writeWarning(
         pht('SHELL'),
         pht(
           'The "SHELL" environment variable is not defined, so it can '.
           'not be used to detect the shell to install rules for.'));
     } else {
       $found = false;
       foreach ($shells as $shell) {
         if ($shell['path'] !== $shell_env) {
           continue;
         }
 
         $found = true;
         $detected[] = $shell['key'];
 
         $log->writeSuccess(
           pht('SHELL'),
           pht(
             'The "SHELL" environment variable has value "%s", so the '.
             'target shell was detected as "%s".',
             $shell_env,
             $shell['key']));
       }
 
       if (!$found) {
         $log->writeStatus(
           pht('SHELL'),
           pht(
             'The "SHELL" environment variable does not match any recognized '.
             'shell.'));
       }
     }
 
     if (!$detected) {
       throw new PhutilArgumentUsageException(
         pht(
           'Unable to detect any supported shell, so autocompletion rules '.
           'can not be installed. Use "--shell" to select a shell.'));
     } else if (count($detected) > 1) {
       throw new PhutilArgumentUsageException(
         pht(
           'Multiple supported shells were detected. Unable to determine '.
           'which shell to install autocompletion rules for. Use "--shell" '.
           'to select a shell.'));
     }
 
     return head($detected);
   }
 
   private function runGenerate() {
     $log = $this->getLogEngine();
 
     $toolsets = ArcanistToolset::newToolsetMap();
 
     $log->writeStatus(
       pht('GENERATE'),
       pht('Generating shell completion rules...'));
 
     $shells = array('bash');
     foreach ($shells as $shell) {
 
       $rules = array();
       foreach ($toolsets as $toolset) {
         $rules[] = $this->newCompletionRules($toolset, $shell);
       }
       $rules = implode("\n", $rules);
 
       $rules_path = $this->getShellPath('rules/'.$shell.'-rules.sh');
 
       // If a write wouldn't change anything, skip the write. This allows
       // "arc shell-complete" to work if "arcanist/" is on a read-only NFS
       // filesystem or something unusual like that.
 
       $skip_write = false;
       if (Filesystem::pathExists($rules_path)) {
         $current = Filesystem::readFile($rules_path);
         if ($current === $rules) {
           $skip_write = true;
         }
       }
 
       if ($skip_write) {
         $log->writeStatus(
           pht('SKIP'),
           pht(
             'Rules are already up to date for "%s" in: %s',
             $shell,
             Filesystem::readablePath($rules_path)));
       } else {
         Filesystem::writeFile($rules_path, $rules);
         $log->writeStatus(
           pht('RULES'),
           pht(
             'Wrote updated completion rules for "%s" to: %s.',
             $shell,
             Filesystem::readablePath($rules_path)));
       }
     }
   }
 
   private function newCompletionRules(ArcanistToolset $toolset, $shell) {
     $template_path = $this->getShellPath('templates/'.$shell.'-template.sh');
     $template = Filesystem::readFile($template_path);
 
     $variables = array(
       'BIN' => $toolset->getToolsetKey(),
     );
 
     foreach ($variables as $key => $value) {
       $template = str_replace('{{{'.$key.'}}}', $value, $template);
     }
 
     return $template;
   }
 
   private function getShellPath($to_file = null) {
     $arc_root = dirname(phutil_get_library_root('arcanist'));
     return $arc_root.'/support/shell/'.$to_file;
   }
 
   private function runAutocomplete() {
     $argv = $this->getArgument('argv');
     $argc = count($argv);
 
     $pos = $this->getArgument('current');
     if (!$pos) {
       $pos = $argc - 1;
     }
 
     if ($pos >= $argc) {
       throw new ArcanistUsageException(
         pht(
           'Argument position specified with "--current" ("%s") is greater '.
           'than the number of arguments provided ("%s").',
           new PhutilNumber($pos),
           new PhutilNumber($argc)));
     }
 
     $workflows = $this->getRuntime()->getWorkflows();
 
     // NOTE: This isn't quite right. For example, "arc --con<tab>" will
     // try to autocomplete workflows named "--con", but it should actually
     // autocomplete global flags and suggest "--config".
 
     $is_workflow = ($pos <= 1);
 
     if ($is_workflow) {
       // NOTE: There was previously some logic to try to filter impossible
       // workflows out of the completion list based on the VCS in the current
       // working directory: for example, if you're in an SVN working directory,
       // "arc a" is unlikely to complete to "arc amend" because "amend" does
       // not support SVN. It's not clear this logic is valuable, but we could
       // consider restoring it if good use cases arise.
 
       // TOOLSETS: Restore the ability for workflows to opt out of shell
       // completion. It is exceptionally unlikely that users want to shell
       // complete obscure or internal workflows, like "arc shell-complete"
       // itself. Perhaps a good behavior would be to offer these as
       // completions if they are the ONLY available completion, since a user
       // who has typed "arc shell-comp<tab>" likely does want "shell-complete".
 
       $complete = array();
       foreach ($workflows as $workflow) {
         $complete[] = $workflow->getWorkflowName();
       }
 
       foreach ($this->getConfig('aliases') as $alias) {
         if ($alias->getException()) {
           continue;
         }
 
         if ($alias->getToolset() !== $this->getToolsetKey()) {
           continue;
         }
 
         $complete[] = $alias->getTrigger();
       }
 
       $partial = $argv[$pos];
       $complete = $this->getMatches($complete, $partial);
 
       if ($complete) {
         return $this->suggestStrings($complete);
       } else {
         return $this->suggestNothing();
       }
 
     } else {
       // TOOLSETS: We should resolve aliases before picking a workflow, so
       // that if you alias "arc draft" to "arc diff --draft", we can suggest
       // other "diff" flags when you type "arc draft --q<tab>".
 
       // TOOLSETS: It's possible the workflow isn't in position 1. The user
       // may be running "arc --trace diff --dra<tab>", for example.
 
       $workflow = idx($workflows, $argv[1]);
       if (!$workflow) {
         return $this->suggestNothing();
       }
 
       $arguments = $workflow->getWorkflowArguments();
       $arguments = mpull($arguments, null, 'getKey');
       $current = idx($argv, $pos, '');
 
       $argument = null;
       $prev = idx($argv, $pos - 1, null);
       if (!strncmp($prev, '--', 2)) {
         $prev = substr($prev, 2);
         $argument = idx($arguments, $prev);
       }
 
       // If the last argument was a "--thing" argument, test if "--thing" is
       // a parameterized argument. If it is, the next argument should be a
       // parameter.
 
       if ($argument && strlen($argument->getParameter())) {
         if ($argument->getIsPathArgument()) {
           return $this->suggestPaths($current);
         } else {
           return $this->suggestNothing();
         }
 
         // TOOLSETS: We can allow workflows and arguments to provide a specific
         // list of completeable values, like the "--shell" argument for this
         // workflow.
       }
 
       $flags = array();
       $wildcard = null;
       foreach ($arguments as $argument) {
         if ($argument->getWildcard()) {
           $wildcard = $argument;
           continue;
         }
 
         $flags[] = '--'.$argument->getKey();
       }
 
       $matches = $this->getMatches($flags, $current);
 
       // If whatever the user is completing does not match the prefix of any
       // flag (or is entirely empty), try to autcomplete a wildcard argument
       // if it has some kind of meaningful completion. For example, "arc lint
       // READ<tab>" should autocomplete a file, and "arc lint <tab>" should
       // suggest files in the current directory.
 
       if (!strlen($current) || !$matches) {
         $try_paths = true;
       } else {
         $try_paths = false;
       }
 
       if ($try_paths && $wildcard) {
         // TOOLSETS: There was previously some very questionable support for
         // autocompleting branches here. This could be moved into Arguments
         // and Workflows.
 
         if ($wildcard->getIsPathArgument()) {
           return $this->suggestPaths($current);
         }
       }
 
       // TODO: If a command has only one flag, like "--json", don't suggest
       // it if the user hasn't typed anything or has only typed "--".
 
       // TODO: Don't suggest "--flag" arguments which aren't repeatable if
       // they are already present in the argument list.
 
       return $this->suggestStrings($matches);
     }
   }
 
   private function suggestPaths($prefix) {
     // NOTE: We are returning a directive to the bash script to run "compgen"
     // for us rather than running it ourselves. If we run:
     //
     //   compgen -A file -- %s
     //
     // ...from this context, it fails (exits with error code 1 and no output)
     // if the prefix is "foo\ ", on my machine. See T9116 for some dicussion.
     echo '<compgen:file>';
     return 0;
   }
 
   private function suggestNothing() {
     return $this->suggestStrings(array());
   }
 
   private function suggestStrings(array $strings) {
     sort($strings);
     echo implode("\n", $strings);
     return 0;
   }
 
   private function getMatches(array $candidates, $prefix) {
     $matches = array();
 
     if (strlen($prefix)) {
       foreach ($candidates as $possible) {
         if (!strncmp($possible, $prefix, strlen($prefix))) {
           $matches[] = $possible;
         }
       }
 
       // If we matched nothing, try a case-insensitive match.
       if (!$matches) {
         foreach ($candidates as $possible) {
           if (!strncasecmp($possible, $prefix, strlen($prefix))) {
             $matches[] = $possible;
           }
         }
       }
     } else {
       $matches = $candidates;
     }
 
     return $matches;
   }
 
 }
diff --git a/src/unit/engine/PhutilUnitTestEngine.php b/src/unit/engine/PhutilUnitTestEngine.php
index 42481434..dc88db4a 100644
--- a/src/unit/engine/PhutilUnitTestEngine.php
+++ b/src/unit/engine/PhutilUnitTestEngine.php
@@ -1,224 +1,222 @@
 <?php
 
 /**
  * Very basic unit test engine which runs libphutil tests.
  */
 final class PhutilUnitTestEngine extends ArcanistUnitTestEngine {
 
   public function getEngineConfigurationName() {
     return 'phutil';
   }
 
   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(pht('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(
             pht(
               'You specified %s but %s is not available, so '.
               'coverage can not be enabled for %s.',
               '--coverage',
               'XDebug',
               __CLASS__));
         }
       } else {
         $enable_coverage = true;
       }
     }
 
     $test_cases = array();
 
     foreach ($run_tests as $test_class) {
       $test_case = newv($test_class, array())
         ->setEnableCoverage($enable_coverage)
         ->setWorkingCopy($this->getWorkingCopy());
 
       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('PhutilTestCase')
       ->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;
   }
 
   /**
    * Retrieve all relevant test cases.
    *
    * Looks for any class that extends @{class:PhutilTestCase} 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.
    *
    * @return list<string>  The names of the test case classes to be executed.
    */
   private function getTestsForPaths() {
     $look_here = $this->getTestPaths();
     $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)
         ->setAncestorClass('PhutilTestCase')
         ->setConcreteOnly(true)
         ->selectAndLoadSymbols();
 
       foreach ($symbols as $symbol) {
         $run_tests[$symbol['name']] = true;
       }
     }
 
     return array_keys($run_tests);
   }
 
   /**
    * Returns the paths in which we should look for tests to execute.
    *
    * @return list<string>  A list of paths in which to search for test cases.
    */
   public function getTestPaths() {
     $root  = $this->getWorkingCopy()->getProjectRoot();
     $paths = 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(
           pht(
-            "Attempting to run unit tests on a libphutil library which has ".
+            "Attempting to run unit tests on a library which has ".
             "not been loaded, at:\n\n".
             "    %s\n\n".
-            "This probably means one of two things:\n\n".
-            "    - You may need to add this library to %s.\n".
-            "    - You may be running tests on a copy of libphutil or ".
-            "arcanist using a different copy of libphutil or arcanist. ".
-            "This operation is not supported.\n",
-            $library_root,
-            '.arcconfig.'));
+            "Make sure this library is configured to load.\n\n".
+            "(In rare cases, this may be because you are attempting to run ".
+            "one copy of this software against a different copy of this ".
+            "software. This operation is not supported.)",
+            $library_root));
       }
 
       $path = Filesystem::resolvePath($path, $root);
       $library_path = Filesystem::readablePath($path, $library_root);
 
       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;
       }
 
       if (is_file($path) && preg_match('@(?:^|/)__tests__/@', $path)) {
         $paths[$library_name.':'.$library_path] = array(
           'library' => $library_name,
           'path'    => $library_path,
         );
         continue;
       }
 
       foreach (Filesystem::walkToRoot($path, $library_root) as $subpath) {
         if ($subpath == $library_root) {
           $paths[$library_name.':.'] = array(
             'library' => $library_name,
             'path'    => '__tests__/',
           );
         } else {
           $library_subpath = Filesystem::readablePath($subpath, $library_root);
 
           $paths[$library_name.':'.$library_subpath] = array(
             'library' => $library_name,
             'path'    => $library_subpath.'/__tests__/',
           );
         }
       }
     }
 
     return $paths;
   }
 
 }
diff --git a/src/unit/engine/phutil/PhutilTestCase.php b/src/unit/engine/phutil/PhutilTestCase.php
index efa946d9..e5f56164 100644
--- a/src/unit/engine/phutil/PhutilTestCase.php
+++ b/src/unit/engine/phutil/PhutilTestCase.php
@@ -1,785 +1,926 @@
 <?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 PhutilTestCase extends Phobject {
 
   private $assertions = 0;
   private $runningTest;
   private $testStartTime;
   private $results = array();
   private $enableCoverage;
   private $coverage = array();
   private $workingCopy;
   private $paths;
   private $renderer;
 
   private static $executables = array();
 
 /* -(  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 .= pht("Expected: %s\n  Actual: %s", $expect, $result);
     } else {
       $output .= pht(
         "Expected vs Actual Output Diff\n%s",
         ArcanistDiffUtils::renderDifferences(
           $expect,
           $result,
           $lines = 0xFFFF));
     }
 
     $this->failTest($output);
     throw new PhutilTestTerminatedException($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 PhutilTestTerminatedException($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 PhutilTestSkippedException($message);
   }
 
+  final protected function assertCaught(
+    $expect,
+    $actual,
+    $message = null) {
+
+    if ($message !== null) {
+      $message = phutil_string_cast($message);
+    }
+
+    if ($actual === null) {
+      // This is okay: no exception.
+    } else if ($actual instanceof Exception) {
+      // This is also okay.
+    } else if ($actual instanceof Throwable) {
+      // And this is okay too.
+    } else {
+      // Anything else is no good.
+
+      if ($message !== null) {
+        $output = pht(
+          'Call to "assertCaught(..., <junk>, ...)" for test case "%s" '.
+          'passed bad value for test result. Expected null, Exception, '.
+          'or Throwable; got: %s.',
+          $message,
+          phutil_describe_type($actual));
+      } else {
+        $output = pht(
+          'Call to "assertCaught(..., <junk>, ...)" passed bad value for '.
+          'test result. Expected null, Exception, or Throwable; got: %s.',
+          phutil_describe_type($actual));
+      }
+
+      $this->failTest($output);
+
+      throw new PhutilTestTerminatedException($output);
+    }
+
+    $expect_list = null;
+
+    if ($expect === false) {
+      $expect_list = array();
+    } else if ($expect === true) {
+      $expect_list = array(
+        'Exception',
+        'Throwable',
+      );
+    } else if (is_string($expect) || is_array($expect)) {
+      $list = (array)$expect;
+
+      $items_ok = true;
+      foreach ($list as $key => $item) {
+        if (!phutil_nonempty_stringlike($item)) {
+          $items_ok = false;
+          break;
+        }
+
+        $list[$key] = phutil_string_cast($item);
+      }
+
+      if ($items_ok) {
+        $expect_list = $list;
+      }
+    }
+
+    if ($expect_list === null) {
+      if ($message !== null) {
+        $output = pht(
+          'Call to "assertCaught(<junk>, ...)" for test case "%s" '.
+          'passed bad expected value. Expected bool, class name as a string, '.
+          'or a list of class names. Got: %s.',
+          $message,
+          phutil_describe_type($expect));
+      } else {
+        $output = pht(
+          'Call to "assertCaught(<junk>, ...)" passed bad expected value. '.
+          'expected result. Expected null, Exception, or Throwable; got: %s.',
+          phutil_describe_type($expect));
+      }
+
+      $this->failTest($output);
+
+      throw new PhutilTestTerminatedException($output);
+    }
+
+    if ($actual === null) {
+      $is_match = !$expect_list;
+    } else {
+      $is_match = false;
+      foreach ($expect_list as $exception_class) {
+        if ($actual instanceof $exception_class) {
+          $is_match = true;
+          break;
+        }
+      }
+    }
+
+    if ($is_match) {
+      $this->assertions++;
+      return;
+    }
+
+    $caller = self::getCallerInfo();
+    $file = $caller['file'];
+    $line = $caller['line'];
+
+    $output = array();
+
+    if ($message !== null) {
+      $output[] = pht(
+        'Assertion of caught exception failed (at %s:%d in test case "%s").',
+        $file,
+        $line,
+        $message);
+    } else {
+      $output[] = pht(
+        'Assertion of caught exception failed (at %s:%d).',
+        $file,
+        $line);
+    }
+
+    if ($actual === null) {
+      $output[] = pht('Expected any exception, got no exception.');
+    } else if (!$expect_list) {
+      $output[] = pht(
+        'Expected no exception, got exception of class "%s".',
+        get_class($actual));
+    } else {
+      $expected_classes = implode(', ', $expect_list);
+      $output[] = pht(
+        'Expected exception (in class(es): %s), got exception of class "%s".',
+        $expected_classes,
+        get_class($actual));
+    }
+
+    $output = implode("\n\n", $output);
+
+    $this->failTest($output);
+
+    throw new PhutilTestTerminatedException($output);
+  }
+
 
 /* -(  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(
         pht('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 PhutilTestTerminatedException) {
           throw $ex;
         }
         if (!($ex instanceof $exception_class)) {
           throw $ex;
         }
         $caught = $ex;
       }
 
       $actual = !($caught instanceof Exception);
 
       if ($expect === $actual) {
         if ($expect) {
           $message = pht("Test case '%s' did not throw, as expected.", $label);
         } else {
           $message = pht("Test case '%s' threw, as expected.", $label);
         }
       } else {
         if ($expect) {
           $message = pht(
             "Test case '%s' was expected to succeed, but it ".
             "raised an exception of class %s with message: %s",
             $label,
             get_class($ex),
             $ex->getMessage());
         } else {
           $message = pht(
             "Test case '%s' was expected to raise an ".
             "exception, but it did not throw anything.",
             $label);
         }
       }
 
       $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<PhutilTestCase> 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<PhutilTestCase> 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() {}
 
 
   /**
    * Mark the currently-running test as a failure.
    *
    * @param string  Human-readable description of problems.
    * @return void
    *
    * @task internal
    */
   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
    */
   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
    */
   private function skipTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_SKIP, $reason);
   }
 
 
   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(
                 '%s assertion(s) passed.',
                 new PhutilNumber($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(
                 pht('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 (PhutilTestTerminatedException $ex) {
           // Continue with the next test.
         } catch (PhutilTestSkippedException $ex) {
           // Continue with the next test.
         } catch (Exception $ex) {
           $ex_class = get_class($ex);
           $ex_message = $ex->getMessage();
           $ex_trace = $ex->getTraceAsString();
           $message = sprintf(
             "%s (%s): %s\n%s",
             pht('EXCEPTION'),
             $ex_class,
             $ex_message,
             $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
    */
   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
    */
   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) {
       $project_root = $this->getProjectRoot();
 
       if (strncmp($file, $project_root, strlen($project_root))) {
         continue;
       }
 
       $max = max(array_keys($report));
       $str = '';
       for ($ii = 1; $ii <= $max; $ii++) {
         $c = null;
         if (isset($report[$ii])) {
           $c = $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($project_root) + 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;
   }
 
   private function assertCoverageAvailable() {
     if (!function_exists('xdebug_start_code_coverage')) {
       throw new Exception(
         pht("You've enabled code coverage but XDebug is not installed."));
     }
   }
 
   final public function getWorkingCopy() {
     return $this->workingCopy;
   }
 
   final public function setWorkingCopy(
     ArcanistWorkingCopyIdentity $working_copy) {
 
     $this->workingCopy = $working_copy;
     return $this;
   }
 
   final public function getProjectRoot() {
     $working_copy = $this->getWorkingCopy();
 
     if (!$working_copy) {
       throw new PhutilInvalidStateException('setWorkingCopy');
     }
 
     return $working_copy->getProjectRoot();
   }
 
   final public function setPaths(array $paths) {
     $this->paths = $paths;
     return $this;
   }
 
   final protected function getLink($method) {
     $base_uri = $this
       ->getWorkingCopy()
       ->getProjectConfig('phabricator.uri');
 
     $uri = id(new PhutilURI($base_uri))
       ->setPath("/diffusion/symbol/{$method}/")
       ->setQueryParam('context', get_class($this))
       ->setQueryParam('jump', 'true')
       ->setQueryParam('lang', 'php');
 
     return (string)$uri;
   }
 
   final public function setRenderer(ArcanistUnitRenderer $renderer) {
     $this->renderer = $renderer;
     return $this;
   }
 
   /**
    * Returns info about the caller function.
    *
    * @return map
    */
   private static 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 PhutilTestTerminatedException($output);
   }
 
   final protected function assertExecutable($binary) {
     if (!isset(self::$executables[$binary])) {
       switch ($binary) {
         case 'xhpast':
           $ok = true;
           if (!PhutilXHPASTBinary::isAvailable()) {
             try {
               PhutilXHPASTBinary::build();
             } catch (Exception $ex) {
               $ok = false;
             }
           }
           break;
         default:
           $ok = Filesystem::binaryExists($binary);
           break;
       }
 
       self::$executables[$binary] = $ok;
     }
 
     if (!self::$executables[$binary]) {
       $this->assertSkipped(
         pht('Required executable "%s" is not available.', $binary));
     }
   }
 
   final protected function getSupportExecutable($executable) {
     $root = dirname(phutil_get_library_root('arcanist'));
     return $root.'/support/unit/'.$executable.'.php';
   }
 
 
 }
diff --git a/src/upload/ArcanistFileUploader.php b/src/upload/ArcanistFileUploader.php
index cde462e7..2af3ae25 100644
--- a/src/upload/ArcanistFileUploader.php
+++ b/src/upload/ArcanistFileUploader.php
@@ -1,319 +1,319 @@
 <?php
 
 /**
  * Upload a list of @{class:ArcanistFileDataRef} objects over Conduit.
  *
  *   // Create a new uploader.
  *   $uploader = id(new ArcanistFileUploader())
  *     ->setConduitEngine($conduit);
  *
  *   // Queue one or more files to be uploaded.
  *   $file = id(new ArcanistFileDataRef())
  *     ->setName('example.jpg')
  *     ->setPath('/path/to/example.jpg');
  *   $uploader->addFile($file);
  *
  *   // Upload the files.
  *   $files = $uploader->uploadFiles();
  *
  * For details about building file references, see @{class:ArcanistFileDataRef}.
  *
  * @task config Configuring the Uploader
  * @task add Adding Files
  * @task upload Uploading Files
  * @task internal Internals
  */
 final class ArcanistFileUploader extends Phobject {
 
   private $conduitEngine;
   private $files = array();
 
 
 /* -(  Configuring the Uploader  )------------------------------------------- */
 
   public function setConduitEngine(ArcanistConduitEngine $engine) {
     $this->conduitEngine = $engine;
     return $this;
   }
 
 
 /* -(  Adding Files  )------------------------------------------------------- */
 
 
   /**
    * Add a file to the list of files to be uploaded.
    *
    * You can optionally provide an explicit key which will be used to identify
    * the file. After adding files, upload them with @{method:uploadFiles}.
    *
    * @param ArcanistFileDataRef File data to upload.
    * @param null|string Optional key to use to identify this file.
    * @return this
    * @task add
    */
   public function addFile(ArcanistFileDataRef $file, $key = null) {
 
     if ($key === null) {
       $this->files[] = $file;
     } else {
       if (isset($this->files[$key])) {
         throw new Exception(
           pht(
             'Two files were added with identical explicit keys ("%s"); each '.
             'explicit key must be unique.',
             $key));
       }
       $this->files[$key] = $file;
     }
 
     return $this;
   }
 
 
 /* -(  Uploading Files  )---------------------------------------------------- */
 
 
   /**
    * Upload files to the server.
    *
    * This transfers all files which have been queued with @{method:addFiles}
    * over the Conduit link configured with @{method:setConduitEngine}.
    *
    * This method returns a map of all file data references. If references were
    * added with an explicit key when @{method:addFile} was called, the key is
    * retained in the result map.
    *
    * On return, files are either populated with a PHID (indicating a successful
    * upload) or a list of errors. See @{class:ArcanistFileDataRef} for
    * details.
    *
    * @return map<string, ArcanistFileDataRef> Files with results populated.
    * @task upload
    */
   public function uploadFiles() {
     if (!$this->conduitEngine) {
       throw new PhutilInvalidStateException('setConduitEngine');
     }
 
     $files = $this->files;
     foreach ($files as $key => $file) {
       try {
         $file->willUpload();
       } catch (Exception $ex) {
         $file->didFail($ex->getMessage());
         unset($files[$key]);
       }
     }
 
     $conduit = $this->conduitEngine;
     $futures = array();
     foreach ($files as $key => $file) {
       $params = $this->getUploadParameters($file) + array(
         'contentLength' => $file->getByteSize(),
         'contentHash' => $file->getContentHash(),
       );
 
       $delete_after = $file->getDeleteAfterEpoch();
       if ($delete_after !== null) {
         $params['deleteAfterEpoch'] = $delete_after;
       }
 
       $futures[$key] = $conduit->newFuture('file.allocate', $params);
     }
 
     $iterator = id(new FutureIterator($futures))->limit(4);
     $chunks = array();
     foreach ($iterator as $key => $future) {
       try {
         $result = $future->resolve();
       } catch (Exception $ex) {
         // The most likely cause for a failure here is that the server does
         // not support `file.allocate`. In this case, we'll try the older
         // upload method below.
         continue;
       }
 
       $phid = $result['filePHID'];
       $file = $files[$key];
 
       // We don't need to upload any data. Figure out why not: this can either
       // be because of an error (server can't accept the data) or because the
       // server already has the data.
       if (!$result['upload']) {
         if (!$phid) {
           $file->didFail(
             pht(
               'Unable to upload file: the server refused to accept file '.
               '"%s". This usually means it is too large.',
               $file->getName()));
         } else {
           // These server completed the upload by creating a reference to known
           // file data. We don't need to transfer the actual data, and are all
           // set.
           $file->setPHID($phid);
         }
         unset($files[$key]);
         continue;
       }
 
       // The server wants us to do an upload.
       if ($phid) {
         $chunks[$key] = array(
           'file' => $file,
           'phid' => $phid,
         );
       }
     }
 
     foreach ($chunks as $key => $chunk) {
       $file = $chunk['file'];
       $phid = $chunk['phid'];
       try {
         $this->uploadChunks($file, $phid);
         $file->setPHID($phid);
       } catch (Exception $ex) {
         $file->didFail(
           pht(
             'Unable to upload file chunks: %s',
             $ex->getMessage()));
       }
       unset($files[$key]);
     }
 
     foreach ($files as $key => $file) {
       try {
         $phid = $this->uploadData($file);
         $file->setPHID($phid);
       } catch (Exception $ex) {
         $file->didFail(
           pht(
             'Unable to upload file data: %s',
             $ex->getMessage()));
       }
       unset($files[$key]);
     }
 
     foreach ($this->files as $file) {
       $file->didUpload();
     }
 
     return $this->files;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Upload missing chunks of a large file by calling `file.uploadchunk` over
    * Conduit.
    *
    * @task internal
    */
   private function uploadChunks(ArcanistFileDataRef $file, $file_phid) {
     $conduit = $this->conduitEngine;
 
     $future = $conduit->newFuture(
       'file.querychunks',
       array(
         'filePHID' => $file_phid,
       ));
     $chunks = $future->resolve();
 
     $remaining = array();
     foreach ($chunks as $chunk) {
       if (!$chunk['complete']) {
         $remaining[] = $chunk;
       }
     }
 
     $done = (count($chunks) - count($remaining));
 
     if ($done) {
       $this->writeStatus(
         pht(
           'Resuming upload (%s of %s chunks remain).',
           phutil_count($remaining),
           phutil_count($chunks)));
     } else {
       $this->writeStatus(
         pht(
           'Uploading chunks (%s chunks to upload).',
           phutil_count($remaining)));
     }
 
     $progress = new PhutilConsoleProgressBar();
     $progress->setTotal(count($chunks));
 
     for ($ii = 0; $ii < $done; $ii++) {
       $progress->update(1);
     }
 
     $progress->draw();
 
     // TODO: We could do these in parallel to improve upload performance.
     foreach ($remaining as $chunk) {
       $data = $file->readBytes($chunk['byteStart'], $chunk['byteEnd']);
 
       $future = $conduit->newFuture(
         'file.uploadchunk',
         array(
           'filePHID' => $file_phid,
           'byteStart' => $chunk['byteStart'],
           'dataEncoding' => 'base64',
           'data' => base64_encode($data),
         ));
       $future->resolve();
 
       $progress->update(1);
     }
   }
 
 
   /**
    * Upload an entire file by calling `file.upload` over Conduit.
    *
    * @task internal
    */
   private function uploadData(ArcanistFileDataRef $file) {
     $conduit = $this->conduitEngine;
 
     $data = $file->readBytes(0, $file->getByteSize());
 
     $future = $conduit->newFuture(
       'file.upload',
       $this->getUploadParameters($file) + array(
         'data_base64' => base64_encode($data),
       ));
 
     return $future->resolve();
   }
 
 
   /**
    * Get common parameters for file uploads.
    */
   private function getUploadParameters(ArcanistFileDataRef $file) {
     $params = array(
       'name' => $file->getName(),
     );
 
     $view_policy = $file->getViewPolicy();
     if ($view_policy !== null) {
       $params['viewPolicy'] = $view_policy;
     }
 
     return $params;
   }
 
 
   /**
    * Write a status message.
    *
    * @task internal
    */
   private function writeStatus($message) {
-    fwrite(STDERR, $message."\n");
+    PhutilSystem::writeStderr($message."\n");
   }
 
 }
diff --git a/src/utils/PhutilSystem.php b/src/utils/PhutilSystem.php
index 6c6d5dcd..d2c053a5 100644
--- a/src/utils/PhutilSystem.php
+++ b/src/utils/PhutilSystem.php
@@ -1,164 +1,227 @@
 <?php
 
 /**
  * Interact with the operating system.
  *
+ * @task stdio Interacting with Standard I/O
  * @task memory Interacting with System Memory
  */
 final class PhutilSystem extends Phobject {
 
+  private static $stdin = false;
+  private static $stderr = false;
+  private static $stdout = false;
+
+  /**
+   * @task stdio
+   */
+  public static function getStdinHandle() {
+    if (self::$stdin === false) {
+      self::$stdin = self::getStdioHandle('STDIN');
+    }
+
+    return self::$stdin;
+  }
+
+  /**
+   * @task stdio
+   */
+  public static function getStdoutHandle() {
+    if (self::$stdout === false) {
+      self::$stdout = self::getStdioHandle('STDOUT');
+    }
+
+    return self::$stdout;
+  }
+
+  /**
+   * @task stdio
+   */
+  public static function getStderrHandle() {
+    if (self::$stderr === false) {
+      self::$stderr = self::getStdioHandle('STDERR');
+    }
+
+    return self::$stderr;
+  }
+
+  /**
+   * @task stdio
+   */
+  public static function writeStderr($message) {
+    $stderr = self::getStderrHandle();
+
+    if ($stderr === null) {
+      return;
+    }
+
+    $message = phutil_string_cast($message);
+    @fwrite($stderr, $message);
+  }
+
+
+  /**
+   * @task stdio
+   */
+  private static function getStdioHandle($ref) {
+    if (defined($ref)) {
+      return constant($ref);
+    }
+
+    return null;
+  }
 
   /**
    * Get information about total and free memory on the system.
    *
    * Because "free memory" is a murky concept, the interpretation of the values
    * returned from this method will vary from system to system and the numbers
    * themselves may be only roughly accurate.
    *
    * @return map<string, wild> Dictionary of memory information.
    * @task memory
    */
   public static function getSystemMemoryInformation() {
     $meminfo_path = '/proc/meminfo';
     if (Filesystem::pathExists($meminfo_path)) {
       $meminfo_data = Filesystem::readFile($meminfo_path);
       return self::parseMemInfo($meminfo_data);
     } else if (Filesystem::binaryExists('vm_stat')) {
       list($vm_stat_stdout) = execx('vm_stat');
       return self::parseVMStat($vm_stat_stdout);
     } else {
       throw new Exception(
         pht(
           'Unable to access %s or `%s` on this system to '.
           'get system memory information.',
           '/proc/meminfo',
           'vm_stat'));
     }
   }
 
 
   /**
    * Parse the output of `/proc/meminfo`.
    *
    * See @{method:getSystemMemoryInformation}. This method is used to get memory
    * information on Linux.
    *
    * @param string Raw `/proc/meminfo`.
    * @return map<string, wild> Parsed memory information.
    * @task memory
    */
   public static function parseMemInfo($data) {
     $data = phutil_split_lines($data);
 
     $map = array();
     foreach ($data as $line) {
       list($key, $value) = explode(':', $line, 2);
       $key = trim($key);
       $value = trim($value);
 
       $matches = null;
       if (preg_match('/^(\d+) kB\z/', $value, $matches)) {
         $value = (int)$matches[1] * 1024;
       }
 
       $map[$key] = $value;
     }
 
     $expect = array(
       'MemTotal',
       'MemFree',
       'Buffers',
       'Cached',
     );
     foreach ($expect as $key) {
       if (!array_key_exists($key, $map)) {
         throw new Exception(
           pht(
             'Expected to find "%s" in "%s" output, but did not.',
             $key,
             '/proc/meminfo'));
       }
     }
 
     $total = $map['MemTotal'];
     $free = $map['MemFree'] + $map['Buffers'] + $map['Cached'];
 
     return array(
       'total' => $total,
       'free' => $free,
     );
   }
 
 
   /**
    * Parse the output of `vm_stat`.
    *
    * See @{method:getSystemMemoryInformation}. This method is used to get memory
    * information on Mac OS X.
    *
    * @param string Raw `vm_stat` output.
    * @return map<string, wild> Parsed memory information.
    * @task memory
    */
   public static function parseVMStat($data) {
     $data = phutil_split_lines($data);
 
     $page_size = null;
     $map = array();
 
     foreach ($data as $line) {
       list($key, $value) = explode(':', $line, 2);
       $key = trim($key);
       $value = trim($value);
 
       $matches = null;
       if (preg_match('/page size of (\d+) bytes/', $value, $matches)) {
         $page_size = (int)$matches[1];
         continue;
       }
 
       $value = trim($value, '.');
       $map[$key] = $value;
     }
 
     if (!$page_size) {
       throw new Exception(
         pht(
           'Expected to find "%s" in `%s` output, but did not.',
           'page size',
           'vm_stat'));
     }
 
     $expect = array(
       'Pages free',
       'Pages active',
       'Pages inactive',
       'Pages wired down',
     );
     foreach ($expect as $key) {
       if (!array_key_exists($key, $map)) {
         throw new Exception(
           pht(
             'Expected to find "%s" in `%s` output, but did not.',
             $key,
             'vm_stat'));
       }
     }
 
     // NOTE: This calculation probably isn't quite right. In particular,
     // the numbers don't exactly add up, and "Pages inactive" includes a
     // bunch of disk cache. So these numbers aren't totally reliable and they
     // aren't directly comparable to the /proc/meminfo numbers.
 
     $free = $map['Pages free'];
     $active = $map['Pages active'];
     $inactive = $map['Pages inactive'];
     $wired = $map['Pages wired down'];
 
     return array(
       'total' => ($free + $active + $inactive + $wired) * $page_size,
       'free' => ($free) * $page_size,
     );
   }
 
 }
diff --git a/src/utils/__tests__/PhutilUtilsTestCase.php b/src/utils/__tests__/PhutilUtilsTestCase.php
index 75fe4692..0d4c898f 100644
--- a/src/utils/__tests__/PhutilUtilsTestCase.php
+++ b/src/utils/__tests__/PhutilUtilsTestCase.php
@@ -1,1003 +1,1073 @@
 <?php
 
 /**
  * Test cases for functions in utils.php.
  */
 final class PhutilUtilsTestCase extends PhutilTestCase {
 
   public function testMFilterNullMethodThrowException() {
     $caught = null;
     try {
       mfilter(array(), null);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
   }
 
 
   public function testMFilterWithEmptyValueFiltered() {
     $a = new MFilterTestHelper('o', 'p', 'q');
     $b = new MFilterTestHelper('o', '', 'q');
     $c = new MFilterTestHelper('o', 'p', 'q');
 
     $list = array(
       'a' => $a,
       'b' => $b,
       'c' => $c,
     );
 
     $actual = mfilter($list, 'getI');
     $expected = array(
      'a' => $a,
      'c' => $c,
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testMFilterWithEmptyValueNegateFiltered() {
     $a = new MFilterTestHelper('o', 'p', 'q');
     $b = new MFilterTestHelper('o', '', 'q');
     $c = new MFilterTestHelper('o', 'p', 'q');
 
     $list = array(
       'a' => $a,
       'b' => $b,
       'c' => $c,
     );
 
     $actual = mfilter($list, 'getI', true);
     $expected = array(
       'b' => $b,
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testIFilterInvalidIndexThrowException() {
     $caught = null;
     try {
       ifilter(array(), null);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
   }
 
   public function testIFilterWithEmptyValueFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
       'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
       'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
       'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
     );
 
     $actual = ifilter($list, 'i');
     $expected = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testIFilterIndexNotExistsAllFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
     );
 
      $actual = ifilter($list, 'NoneExisting');
      $expected = array();
 
      $this->assertEqual($expected, $actual);
   }
 
 
   public function testIFilterWithEmptyValueNegateFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
       'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
       'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
       'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
     );
 
     $actual = ifilter($list, 'i', true);
     $expected = array(
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
       'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
       'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
       'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testIFilterIndexNotExistsNotFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
     );
 
     $actual = ifilter($list, 'NoneExisting', true);
     $expected = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testmergevMergingBasicallyWorksCorrectly() {
     $this->assertEqual(
       array(),
       array_mergev(
         array(
           // <empty>
         )));
 
     $this->assertEqual(
       array(),
       array_mergev(
         array(
           array(),
           array(),
           array(),
         )));
 
     $this->assertEqual(
       array(1, 2, 3, 4, 5),
       array_mergev(
         array(
           array(1, 2),
           array(3),
           array(),
           array(4, 5),
         )));
 
     $not_valid = array(
       'scalar' => array(1),
       'array plus scalar' => array(array(), 1),
       'null' => array(null),
     );
 
     foreach ($not_valid as $key => $invalid_input) {
       $caught = null;
       try {
         array_mergev($invalid_input);
       } catch (InvalidArgumentException $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue(
         ($caught instanceof InvalidArgumentException),
         pht('%s invalid on %s', 'array_mergev()', $key));
     }
   }
 
   public function testNonempty() {
     $this->assertEqual(
       'zebra',
       nonempty(false, null, 0, '', array(), 'zebra'));
 
     $this->assertEqual(
       null,
       nonempty());
 
     $this->assertEqual(
       false,
       nonempty(null, false));
 
     $this->assertEqual(
       null,
       nonempty(false, null));
   }
 
   protected function tryAssertInstancesOfArray($input) {
     assert_instances_of($input, 'array');
   }
 
   protected function tryAssertInstancesOfStdClass($input) {
     assert_instances_of($input, 'stdClass');
   }
 
   public function testAssertInstancesOf() {
     $object = new stdClass();
     $inputs = array(
       'empty' => array(),
       'stdClass' => array($object, $object),
       __CLASS__ => array($object, $this),
       'array' => array(array(), array()),
       'integer' => array($object, 1),
     );
 
     $this->tryTestCases(
       $inputs,
       array(true, true, false, false, false),
       array($this, 'tryAssertInstancesOfStdClass'),
       'InvalidArgumentException');
 
     $this->tryTestCases(
       $inputs,
       array(true, false, false, true, false),
       array($this, 'tryAssertInstancesOfArray'),
       'InvalidArgumentException');
   }
 
   public function testAssertSameKeys() {
     $cases = array(
       array(true, array(), array()),
       array(true, array(0), array(1)),
 
       array(false, array(0), array()),
       array(false, array(), array(0)),
 
       array(false, array('a' => 1), array('b' => 1)),
 
       // Make sure "null" values survive "isset()" tests.
       array(true, array('a' => 1), array('a' => null)),
 
       // Key order should not matter.
       array(true, array('a' => 1, 'b' => 1), array('b' => 1, 'a' => 1)),
     );
 
     foreach ($cases as $case) {
       list($same_keys, $expect, $input) = $case;
 
       $caught = null;
       try {
         assert_same_keys($expect, $input);
       } catch (InvalidArgumentException $ex) {
         $caught = $ex;
       }
 
       $this->assertEqual($same_keys, ($caught === null));
     }
   }
 
   public function testAssertStringLike() {
     $this->assertEqual(
       null,
       assert_stringlike(null));
 
     $this->assertEqual(
       null,
       assert_stringlike(''));
 
     $this->assertEqual(
       null,
       assert_stringlike('Hello World'));
 
     $this->assertEqual(
       null,
       assert_stringlike(1));
 
     $this->assertEqual(
       null,
       assert_stringlike(9.9999));
 
     $this->assertEqual(
       null,
       assert_stringlike(true));
 
     $obj = new Exception('.');
     $this->assertEqual(
       null,
       assert_stringlike($obj));
 
     $obj = (object)array();
 
     try {
       assert_stringlike($obj);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
 
     $array = array(
       'foo' => 'bar',
       'bar' => 'foo',
     );
 
     try {
       assert_stringlike($array);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
 
     $tmp = new TempFile();
     $resource = fopen($tmp, 'r');
 
     try {
       assert_stringlike($resource);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     fclose($resource);
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
   }
 
   public function testCoalesce() {
     $this->assertEqual(
       'zebra',
       coalesce(null, 'zebra'));
 
     $this->assertEqual(
       null,
       coalesce());
 
     $this->assertEqual(
       false,
       coalesce(false, null));
 
     $this->assertEqual(
       false,
       coalesce(null, false));
   }
 
   public function testHeadLast() {
     $this->assertEqual(
       'a',
       head(explode('.', 'a.b')));
     $this->assertEqual(
       'b',
       last(explode('.', 'a.b')));
   }
 
   public function testHeadKeyLastKey() {
     $this->assertEqual(
       'a',
       head_key(array('a' => 0, 'b' => 1)));
     $this->assertEqual(
       'b',
       last_key(array('a' => 0, 'b' => 1)));
     $this->assertEqual(null, head_key(array()));
     $this->assertEqual(null, last_key(array()));
   }
 
   public function testID() {
     $this->assertEqual(true, id(true));
     $this->assertEqual(false, id(false));
   }
 
   public function testIdx() {
     $array = array(
       'present' => true,
       'null' => null,
     );
     $this->assertEqual(true, idx($array, 'present'));
     $this->assertEqual(true, idx($array, 'present', false));
     $this->assertEqual(null, idx($array, 'null'));
     $this->assertEqual(null, idx($array, 'null', false));
     $this->assertEqual(null, idx($array, 'missing'));
     $this->assertEqual(false, idx($array, 'missing', false));
   }
 
   public function testSplitLines() {
     $retain_cases = array(
       '' => array(''),
       'x' => array('x'),
       "x\n" => array("x\n"),
       "\n" => array("\n"),
       "\n\n\n" => array("\n", "\n", "\n"),
       "\r\n" => array("\r\n"),
       "x\r\ny\n" => array("x\r\n", "y\n"),
       "x\ry\nz\r\n" => array("x\ry\n", "z\r\n"),
       "x\ry\nz\r\n\n" => array("x\ry\n", "z\r\n", "\n"),
     );
 
     foreach ($retain_cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_split_lines($input, $retain_endings = true),
         pht('(Retained) %s', addcslashes($input, "\r\n\\")));
     }
 
     $discard_cases = array(
       '' => array(''),
       'x' => array('x'),
       "x\n" => array('x'),
       "\n" => array(''),
       "\n\n\n" => array('', '', ''),
       "\r\n" => array(''),
       "x\r\ny\n" => array('x', 'y'),
       "x\ry\nz\r\n" => array("x\ry", 'z'),
       "x\ry\nz\r\n\n" => array("x\ry", 'z', ''),
     );
 
     foreach ($discard_cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_split_lines($input, $retain_endings = false),
         pht('(Discarded) %s', addcslashes($input, "\r\n\\")));
     }
   }
 
   public function testArrayFuse() {
     $this->assertEqual(array(), array_fuse(array()));
     $this->assertEqual(array('x' => 'x'), array_fuse(array('x')));
   }
 
   public function testArrayInterleave() {
     $this->assertEqual(array(), array_interleave('x', array()));
     $this->assertEqual(array('y'), array_interleave('x', array('y')));
 
     $this->assertEqual(
       array('y', 'x', 'z'),
       array_interleave('x', array('y', 'z')));
 
     $this->assertEqual(
       array('y', 'x', 'z'),
       array_interleave(
         'x',
         array(
           'kangaroo' => 'y',
           'marmoset' => 'z',
         )));
 
     $obj1 = (object)array();
     $obj2 = (object)array();
 
     $this->assertEqual(
       array($obj1, $obj2, $obj1, $obj2, $obj1),
       array_interleave(
         $obj2,
         array(
           $obj1,
           $obj1,
           $obj1,
         )));
 
     $implode_tests = array(
       '' => array(1, 2, 3),
       'x' => array(1, 2, 3),
       'y' => array(),
       'z' => array(1),
     );
 
     foreach ($implode_tests as $x => $y) {
       $this->assertEqual(
         implode('', array_interleave($x, $y)),
         implode($x, $y));
     }
   }
 
   public function testLoggableString() {
     $this->assertEqual(
       '',
       phutil_loggable_string(''));
 
     $this->assertEqual(
       "a\\nb",
       phutil_loggable_string("a\nb"));
 
     $this->assertEqual(
       "a\\x01b",
       phutil_loggable_string("a\x01b"));
 
     $this->assertEqual(
       "a\\x1Fb",
       phutil_loggable_string("a\x1Fb"));
   }
 
   public function testPhutilUnits() {
     $cases = array(
       '0 seconds in seconds' => 0,
       '1 second in seconds' => 1,
       '2 seconds in seconds' => 2,
       '100 seconds in seconds' => 100,
       '2 minutes in seconds' => 120,
       '1 hour in seconds' => 3600,
       '1 day in seconds' => 86400,
       '3 days in seconds' => 259200,
       '128 bits in bytes' => 16,
       '1 byte in bytes' => 1,
       '8 bits in bytes' => 1,
       '1 minute in milliseconds' => 60000,
       '2 minutes in microseconds' => 120000000,
     );
 
     foreach ($cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_units($input),
         'phutil_units("'.$input.'")');
     }
 
     $bad_cases = array(
       'quack',
       '3 years in seconds',
       '1 day in days',
       '-1 minutes in seconds',
       '1.5 minutes in seconds',
       '7 bits in bytes',
       '2 hours in bytes',
       '1 dram in bytes',
       '24 bits in seconds',
     );
 
     foreach ($bad_cases as $input) {
       $caught = null;
       try {
         phutil_units($input);
       } catch (InvalidArgumentException $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue(
         ($caught instanceof InvalidArgumentException),
         'phutil_units("'.$input.'")');
     }
   }
 
   public function testPhutilJSONDecode() {
     $valid_cases = array(
       '{}' => array(),
       '[]' => array(),
       '[1, 2]' => array(1, 2),
       '{"a":"b"}' => array('a' => 'b'),
     );
 
     foreach ($valid_cases as $input => $expect) {
       $result = phutil_json_decode($input);
       $this->assertEqual($expect, $result, 'phutil_json_decode('.$input.')');
     }
 
     $invalid_cases = array(
       '',
       '"a"',
       '{,}',
       'null',
       '"null"',
     );
 
     foreach ($invalid_cases as $input) {
       $caught = null;
       try {
         phutil_json_decode($input);
       } catch (Exception $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue($caught instanceof PhutilJSONParserException);
     }
   }
 
   public function testPhutilINIDecode() {
     // Skip the test if we are using an older version of PHP that doesn't
     // have the `parse_ini_string` function.
     try {
       phutil_ini_decode('');
     } catch (PhutilMethodNotImplementedException $ex) {
       $this->assertSkipped($ex->getMessage());
     }
 
     $valid_cases = array(
       '' => array(),
       'foo=' => array('foo' => ''),
       'foo=bar' => array('foo' => 'bar'),
       'foo = bar' => array('foo' => 'bar'),
       "foo = bar\n" => array('foo' => 'bar'),
       "foo\nbar = baz" => array('bar' => 'baz'),
 
       "[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
       "[foo]\n[bar]\nbaz = foo" => array(
         'foo' => array(),
         'bar' => array('baz' => 'foo'),
       ),
       "[foo]\nbar = baz\n\n[bar]\nbaz = foo" => array(
         'foo' => array('bar' => 'baz'),
         'bar' => array('baz' => 'foo'),
       ),
 
       "; Comment\n[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
       "# Comment\n[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
 
       "foo = true\n[bar]\nbaz = false"
         => array('foo' => true, 'bar' => array('baz' => false)),
       "foo = 1\nbar = 1.234" => array('foo' => 1, 'bar' => 1.234),
       'x = {"foo": "bar"}' => array('x' => '{"foo": "bar"}'),
     );
 
     foreach ($valid_cases as $input => $expect) {
       $result = phutil_ini_decode($input);
       $this->assertEqual($expect, $result, 'phutil_ini_decode('.$input.')');
     }
 
     $invalid_cases = array(
       '[' => new PhutilINIParserException(),
     );
 
     foreach ($invalid_cases as $input => $expect) {
       $caught = null;
       try {
         phutil_ini_decode($input);
       } catch (Exception $ex) {
         $caught = $ex;
       }
       $this->assertTrue($caught instanceof $expect);
     }
   }
 
   public function testCensorCredentials() {
     $cases = array(
       '' => '',
       'abc' => 'abc',
 
       // NOTE: We're liberal about censoring here, since we can't tell
       // if this is a truncated password at the end of an input string
       // or a domain name. The version with a "/" isn't censored.
       'http://example.com' => 'http://********',
       'http://example.com/' => 'http://example.com/',
 
       'http://username@example.com' => 'http://********@example.com',
       'http://user:pass@example.com' => 'http://********@example.com',
 
       // We censor these because they might be truncated credentials at the end
       // of the string.
       'http://user' => 'http://********',
       "http://user\n" => "http://********\n",
 
       'svn+ssh://user:pass@example.com' => 'svn+ssh://********@example.com',
     );
 
     foreach ($cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_censor_credentials($input),
         pht('Credential censoring for: %s', $input));
     }
   }
 
   public function testVarExport() {
     // Constants
     $this->assertEqual('null', phutil_var_export(null));
     $this->assertEqual('true', phutil_var_export(true));
     $this->assertEqual('false', phutil_var_export(false));
     $this->assertEqual("'quack'", phutil_var_export('quack'));
     $this->assertEqual('1234567', phutil_var_export(1234567));
 
     // Arrays
     $this->assertEqual(
       'array()',
       phutil_var_export(array()));
     $this->assertEqual(
       implode("\n", array(
         'array(',
         '  1,',
         '  2,',
         '  3,',
         ')',
       )),
       phutil_var_export(array(1, 2, 3)));
     $this->assertEqual(
       implode("\n", array(
         'array(',
         "  'foo' => 'bar',",
         "  'bar' => 'baz',",
         ')',
       )),
       phutil_var_export(array('foo' => 'bar', 'bar' => 'baz')));
     $this->assertEqual(
       implode("\n", array(
         'array(',
         "  'foo' => array(",
         "    'bar' => array(",
         "      'baz' => array(),",
         '    ),',
         '  ),',
         ')',
       )),
       phutil_var_export(
         array('foo' => array('bar' => array('baz' => array())))));
 
     // NOTE: Object behavior differs across PHP versions. Older versions of
     // PHP export objects as "stdClass::__set_state(array())". Newer versions
     // of PHP (7.3+) export objects as "(object) array()".
   }
 
   public function testFnmatch() {
     $cases = array(
       '' => array(
         array(''),
         array('.', '/'),
       ),
       '*' => array(
         array('file'),
         array('dir/', '/dir'),
       ),
       '**' => array(
         array('file', 'dir/', '/dir', 'dir/subdir/file'),
         array(),
       ),
       '**/file' => array(
         array('file', 'dir/file', 'dir/subdir/file', 'dir/subdir/subdir/file'),
         array('file/', 'file/dir'),
       ),
       'file.*' => array(
         array('file.php', 'file.a', 'file.'),
         array('files.php', 'file.php/blah'),
       ),
       'fo?' => array(
         array('foo', 'fot'),
         array('fooo', 'ffoo', 'fo/', 'foo/'),
       ),
       'fo{o,t}' => array(
         array('foo', 'fot'),
         array('fob', 'fo/', 'foo/'),
       ),
       'fo{o,\\,}' => array(
         array('foo', 'fo,'),
         array('foo/', 'fo,/'),
       ),
       'fo{o,\\\\}' => array(
         array('foo', 'fo\\'),
         array('foo/', 'fo\\/'),
       ),
       '/foo' => array(
         array('/foo'),
         array('foo', '/foo/'),
       ),
 
       // Tests for various `fnmatch` flags.
       '*.txt' => array(
         array(
           'file.txt',
 
           // FNM_PERIOD
           '.secret-file.txt',
         ),
         array(
           // FNM_PATHNAME
           'dir/file.txt',
 
           // FNM_CASEFOLD
           'file.TXT',
         ),
         '\\*.txt' => array(
           array(
             // FNM_NOESCAPE
             '*.txt',
           ),
           array(
             'file.txt',
           ),
         ),
       ),
     );
 
     $invalid = array(
       '{',
       'asdf\\',
     );
 
     foreach ($cases as $input => $expect) {
       list($matches, $no_matches) = $expect;
 
       foreach ($matches as $match) {
         $this->assertTrue(
           phutil_fnmatch($input, $match),
           pht('Expecting "%s" to match "%s".', $input, $match));
       }
 
       foreach ($no_matches as $no_match) {
         $this->assertFalse(
           phutil_fnmatch($input, $no_match),
           pht('Expecting "%s" not to match "%s".', $input, $no_match));
       }
     }
 
     foreach ($invalid as $input) {
       $caught = null;
       try {
         phutil_fnmatch($input, '');
       } catch (Exception $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue($caught instanceof InvalidArgumentException);
     }
   }
 
   public function testJSONEncode() {
     $in = array(
       'example' => "Not Valid UTF8: \x80",
     );
 
     $caught = null;
     try {
       $value = phutil_json_encode($in);
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue(($caught instanceof Exception));
   }
 
   public function testHashComparisons() {
     $tests = array(
       array('1', '12', false),
       array('0', '0e123', false),
       array('0e123', '0e124', false),
       array('', '0', false),
       array('000', '0e0', false),
       array('001', '002', false),
       array('0', '', false),
       array('987654321', '123456789', false),
       array('A', 'a', false),
       array('123456789', '123456789', true),
       array('hunter42', 'hunter42', true),
     );
 
     foreach ($tests as $key => $test) {
       list($u, $v, $expect) = $test;
       $actual = phutil_hashes_are_identical($u, $v);
       $this->assertEqual(
         $expect,
         $actual,
         pht('Test Case: "%s" vs "%s"', $u, $v));
     }
   }
 
   public function testVectorSortInt() {
     $original = array(
       ~PHP_INT_MAX,
       -2147483648,
       -5,
       -3,
       -1,
       0,
       1,
       2,
       3,
       100,
       PHP_INT_MAX,
     );
 
     $items = $this->shuffleMap($original);
 
     foreach ($items as $key => $value) {
       $items[$key] = (string)id(new PhutilSortVector())
         ->addInt($value);
     }
 
     asort($items, SORT_STRING);
 
     $this->assertEqual(
       array_keys($original),
       array_keys($items));
   }
 
   public function testVectorSortString() {
     $original = array(
       '',
       "\1",
       'A',
       'AB',
       'Z',
       "Z\1",
       'ZZZ',
     );
 
     $items = $this->shuffleMap($original);
 
     foreach ($items as $key => $value) {
       $items[$key] = (string)id(new PhutilSortVector())
         ->addString($value);
     }
 
     asort($items, SORT_STRING);
 
     $this->assertEqual(
       array_keys($original),
       array_keys($items));
   }
 
   private function shuffleMap(array $map) {
     $keys = array_keys($map);
     shuffle($keys);
     return array_select_keys($map, $keys);
   }
 
   public function testQueryStringEncoding() {
     $expect = array();
 
     // As a starting point, we expect every character to encode as an "%XX"
     // escaped version.
     foreach (range(0, 255) as $byte) {
       $c = chr($byte);
       $expect[$c] = sprintf('%%%02X', $byte);
     }
 
     // We expect these characters to not be escaped.
     $ranges = array(
       range('a', 'z'),
       range('A', 'Z'),
       range('0', '9'),
       array('-', '.', '_', '~'),
     );
 
     foreach ($ranges as $range) {
       foreach ($range as $preserve_char) {
         $expect[$preserve_char] = $preserve_char;
       }
     }
 
     foreach (range(0, 255) as $byte) {
       $c = chr($byte);
 
       $expect_c = $expect[$c];
       $expect_str = "{$expect_c}={$expect_c}";
 
       $actual_str = phutil_build_http_querystring(array($c => $c));
 
       $this->assertEqual(
         $expect_str,
         $actual_str,
         pht('HTTP querystring for byte "%s".', sprintf('0x%02x', $byte)));
     }
   }
 
   public function testNaturalList() {
     $cases = array(
       array(true, array()),
       array(true, array(0 => true, 1 => true, 2 => true)),
       array(true, array('a', 'b', 'c')),
       array(false, array(0 => true, 2 => true, 1 => true)),
       array(false, array(1 => true)),
       array(false, array('sound' => 'quack')),
     );
 
     foreach ($cases as $case) {
       list($expect, $value) = $case;
       $this->assertEqual($expect, phutil_is_natural_list($value));
     }
   }
 
   public function testArrayPartition() {
     $map = array(
       'empty' => array(
         array(),
         array(),
       ),
       'unique' => array(
         array('a' => 'a', 'b' => 'b', 'c' => 'c'),
         array(array('a' => 'a'), array('b' => 'b'), array('c' => 'c')),
       ),
       'xy' => array(
         array('a' => 'x', 'b' => 'x', 'c' => 'y', 'd' => 'y'),
         array(
           array('a' => 'x', 'b' => 'x'),
           array('c' => 'y', 'd' => 'y'),
         ),
       ),
       'multi' => array(
         array('a' => true, 'b' => true, 'c' => false, 'd' => true),
         array(
           array('a' => true, 'b' => true),
           array('c' => false),
           array('d' => true),
         ),
       ),
     );
 
     foreach ($map as $name => $item) {
       list($input, $expect) = $item;
       $actual = phutil_partition($input);
       $this->assertEqual($expect, $actual, pht('Partition of "%s"', $name));
     }
   }
 
+  public function testEmptyStringMethods() {
+
+    $uri = new PhutilURI('http://example.org/');
+
+    $map = array(
+      array(null, false, false, false, 'literal null'),
+      array('', false, false, false, 'empty string'),
+      array('x', true, true, true, 'nonempty string'),
+      array(false, null, null, null, 'bool'),
+      array(1, null, null, true, 'integer'),
+      array($uri, null, true, true, 'uri object'),
+      array(2.5, null, null, true, 'float'),
+      array(array(), null, null, null, 'array'),
+      array((object)array(), null, null, null, 'object'),
+    );
+
+    foreach ($map as $test_case) {
+      $input = $test_case[0];
+
+      $expect_string = $test_case[1];
+      $expect_stringlike = $test_case[2];
+      $expect_scalar = $test_case[3];
+
+      $test_name = $test_case[4];
+
+      $this->executeEmptyStringTest(
+        $input,
+        $expect_string,
+        'phutil_nonempty_string',
+        $test_name);
+
+      $this->executeEmptyStringTest(
+        $input,
+        $expect_stringlike,
+        'phutil_nonempty_stringlike',
+        $test_name);
+
+      $this->executeEmptyStringTest(
+        $input,
+        $expect_scalar,
+        'phutil_nonempty_scalar',
+        $test_name);
+    }
+
+  }
+
+  private function executeEmptyStringTest($input, $expect, $call, $name) {
+    $name = sprintf('%s(<%s>)', $call, $name);
+
+    $caught = null;
+    try {
+      $actual = call_user_func($call, $input);
+    } catch (Exception $ex) {
+      $caught = $ex;
+    } catch (Throwable $ex) {
+      $caught = $ex;
+    }
+
+    if ($expect === null) {
+      $expect_exceptions = array('InvalidArgumentException');
+    } else {
+      $expect_exceptions = false;
+    }
+
+    $this->assertCaught($expect_exceptions, $caught, $name);
+    if (!$caught) {
+      $this->assertEqual($expect, $actual, $name);
+    }
+  }
+
 }
diff --git a/src/utils/utf8.php b/src/utils/utf8.php
index c92ee533..06d014fa 100644
--- a/src/utils/utf8.php
+++ b/src/utils/utf8.php
@@ -1,984 +1,986 @@
 <?php
 
 /**
  * Convert a string into valid UTF-8. This function is quite slow.
  *
  * When invalid byte subsequences are encountered, they will be replaced with
  * U+FFFD, the Unicode replacement character.
  *
  * This function treats overlong encodings as invalid.
  *
  * @param   string  String to convert to valid UTF-8.
  * @return  string  String with invalid UTF-8 byte subsequences replaced with
  *                  U+FFFD.
  */
 function phutil_utf8ize($string) {
   if (phutil_is_utf8($string)) {
     return $string;
   }
 
   // There is no function to do this in iconv, mbstring or ICU to do this, so
   // do it (very very slowly) in pure PHP.
 
   // TODO: Provide an optional fast C implementation ala fb_utf8ize() if this
   // ever shows up in profiles?
 
   $result = array();
 
   $regex =
     "/([\x01-\x7F]".
       "|[\xC2-\xDF][\x80-\xBF]".
       "|[\xE0][\xA0-\xBF][\x80-\xBF]".
       "|[\xE1-\xEF][\x80-\xBF][\x80-\xBF]".
       "|[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF]".
       "|[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]".
       "|[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF])".
     "|(.)/";
 
   $replacement = "\xEF\xBF\xBD";
 
   $offset = 0;
   $matches = null;
   while (preg_match($regex, $string, $matches, 0, $offset)) {
     if (!isset($matches[2])) {
       $match = $matches[1];
 
       if ($match[0] == "\xED") {
         // If this is a 3-byte character that may be part of one of the
         // surrogate ranges, check if it's actually in those ranges. Reject
         // it as invalid if it is. These sequences are used in UTF16 and
         // functions like json_encode() refuse to encode them.
 
         $codepoint = ((ord($match[0]) & 0x0F) << 12)
                    + ((ord($match[1]) & 0x3F) << 6)
                    + ((ord($match[2]) & 0x3F));
         if ($codepoint >= 0xD800 && $codepoint <= 0xDFFF) {
           $result[] = str_repeat($replacement, strlen($match));
           $offset += strlen($matches[0]);
           continue;
         }
       }
 
       $result[] = $match;
     } else {
       // Unicode replacement character, U+FFFD.
       $result[] = $replacement;
     }
 
     $offset += strlen($matches[0]);
   }
 
   return implode('', $result);
 }
 
 
 /**
  * Determine if a string is valid UTF-8, with only basic multilingual plane
  * characters. This is particularly important because MySQL's `utf8` column
  * types silently truncate strings which contain characters outside of this
  * set.
  *
  * @param string  String to test for being valid UTF-8 with only characters in
  *                the basic multilingual plane.
  * @return bool   True if the string is valid UTF-8 with only BMP characters.
  */
 function phutil_is_utf8_with_only_bmp_characters($string) {
   return phutil_is_utf8_slowly($string, $only_bmp = true);
 }
 
 
 /**
  * Determine if a string is valid UTF-8.
  *
  * @param string  Some string which may or may not be valid UTF-8.
  * @return bool    True if the string is valid UTF-8.
  */
 function phutil_is_utf8($string) {
   if (function_exists('mb_check_encoding')) {
     // See T13527. In some versions of PHP, "mb_check_encoding()" strictly
     // requires a string parameter.
     $string = phutil_string_cast($string);
 
     // If mbstring is available, this is significantly faster than using PHP.
     return mb_check_encoding($string, 'UTF-8');
   }
 
   return phutil_is_utf8_slowly($string);
 }
 
 
 /**
  * Determine if a string is valid UTF-8, slowly.
  *
  * This works on any system, but has very poor performance.
  *
  * You should call @{function:phutil_is_utf8} instead of this function, as
  * that function can use more performant mechanisms if they are available on
  * the system.
  *
  * @param string  Some string which may or may not be valid UTF-8.
  * @param bool    True to require all characters be part of the basic
  *                multilingual plane (no more than 3-bytes long).
  * @return bool   True if the string is valid UTF-8.
  */
 function phutil_is_utf8_slowly($string, $only_bmp = false) {
   // First, check the common case of normal ASCII strings. We're fine if
   // the string contains no bytes larger than 127.
   if (preg_match('/^[\x01-\x7F]+\z/', $string)) {
     return true;
   }
 
   // NOTE: In the past, we used a large regular expression in the form of
   // '(x|y|z)+' to match UTF8 strings. However, PCRE can segfaults on patterns
   // like this at relatively small input sizes, at least on some systems
   // (observed on OSX and Windows). This is apparently because the internal
   // implementation is recursive and it blows the stack.
 
   // See <https://bugs.php.net/bug.php?id=45735> for some discussion. Since the
   // input limit is extremely low (less than 50KB on my system), do this check
   // very very slowly in PHP instead. See also T5316.
 
   $len = strlen($string);
   for ($ii = 0; $ii < $len; $ii++) {
     $chr = ord($string[$ii]);
     if ($chr >= 0x01 && $chr <= 0x7F) {
       continue;
     } else if ($chr >= 0xC2 && $chr <= 0xDF) {
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
       if ($chr >= 0x80 && $chr <= 0xBF) {
         continue;
       }
       return false;
     } else if ($chr == 0xED) {
       // See T11525. Some sequences in this block are surrogate codepoints
       // that are reserved for use in UTF16. We should reject them.
       $codepoint = ($chr & 0x0F) << 12;
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
       $codepoint += ($chr & 0x3F) << 6;
       if ($chr >= 0x80 && $chr <= 0xBF) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         $codepoint += ($chr & 0x3F);
 
         if ($codepoint >= 0xD800 && $codepoint <= 0xDFFF) {
           // Reject these surrogate codepoints.
           return false;
         }
 
         if ($chr >= 0x80 && $chr <= 0xBF) {
           continue;
         }
       }
       return false;
     } else if ($chr > 0xE0 && $chr <= 0xEF) {
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
       if ($chr >= 0x80 && $chr <= 0xBF) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         if ($chr >= 0x80 && $chr <= 0xBF) {
           continue;
         }
       }
       return false;
     } else if ($chr == 0xE0) {
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
 
       // NOTE: This range starts at 0xA0, not 0x80. The values 0x80-0xA0 are
       // "valid", but not minimal representations, and MySQL rejects them. We're
       // special casing this part of the range.
 
       if ($chr >= 0xA0 && $chr <= 0xBF) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         if ($chr >= 0x80 && $chr <= 0xBF) {
           continue;
         }
       }
       return false;
     } else if (!$only_bmp) {
       if ($chr > 0xF0 && $chr <= 0xF4) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         if ($chr >= 0x80 && $chr <= 0xBF) {
           ++$ii;
           if ($ii >= $len) {
             return false;
           }
           $chr = ord($string[$ii]);
           if ($chr >= 0x80 && $chr <= 0xBF) {
             ++$ii;
             if ($ii >= $len) {
               return false;
             }
             $chr = ord($string[$ii]);
             if ($chr >= 0x80 && $chr <= 0xBF) {
               continue;
             }
           }
         }
       } else if ($chr == 0xF0) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
 
         // NOTE: As above, this range starts at 0x90, not 0x80. The values
         // 0x80-0x90 are not minimal representations.
 
         if ($chr >= 0x90 && $chr <= 0xBF) {
           ++$ii;
           if ($ii >= $len) {
             return false;
           }
           $chr = ord($string[$ii]);
           if ($chr >= 0x80 && $chr <= 0xBF) {
             ++$ii;
             if ($ii >= $len) {
               return false;
             }
             $chr = ord($string[$ii]);
             if ($chr >= 0x80 && $chr <= 0xBF) {
               continue;
             }
           }
         }
       }
     }
 
     return false;
   }
 
   return true;
 }
 
 
 /**
  * Find the character length of a UTF-8 string.
  *
  * @param string A valid utf-8 string.
  * @return int   The character length of the string.
  */
 function phutil_utf8_strlen($string) {
   if (function_exists('utf8_decode')) {
     return strlen(utf8_decode($string));
   }
   return count(phutil_utf8v($string));
 }
 
 
 /**
  * Find the console display length of a UTF-8 string. This may differ from the
  * character length of the string if it contains double-width characters, like
  * many Chinese characters.
  *
  * This method is based on a C implementation here, which is based on the IEEE
  * standards. The source has more discussion and addresses more considerations
  * than this implementation does.
  *
  *   http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
  *
  * NOTE: We currently assume width 1 for East-Asian ambiguous characters.
  *
  * NOTE: This function is VERY slow.
  *
  * @param   string  A valid UTF-8 string.
  * @return  int     The console display length of the string.
  */
 function phutil_utf8_console_strlen($string) {
+  $string = phutil_string_cast($string);
+
   // Formatting and colors don't contribute any width in the console.
   $string = preg_replace("/\x1B\[\d*m/", '', $string);
 
   // In the common case of an ASCII string, just return the string length.
   if (preg_match('/^[\x01-\x7F]*\z/', $string)) {
     return strlen($string);
   }
 
   $len = 0;
 
   // NOTE: To deal with combining characters, we're splitting the string into
   // glyphs first (characters with combiners) and then counting just the width
   // of the first character in each glyph.
 
   $display_glyphs = phutil_utf8v_combined($string);
   foreach ($display_glyphs as $display_glyph) {
     $glyph_codepoints = phutil_utf8v_codepoints($display_glyph);
     foreach ($glyph_codepoints as $c) {
       if ($c == 0) {
         break;
       }
 
       $len += 1 +
         ($c >= 0x1100 &&
           ($c <= 0x115F ||                    /* Hangul Jamo init. consonants */
             $c == 0x2329 || $c == 0x232A ||
             ($c >= 0x2E80 && $c <= 0xA4CF &&
               $c != 0x303F) ||                  /* CJK ... Yi */
             ($c >= 0xAC00 && $c <= 0xD7A3) || /* Hangul Syllables */
             ($c >= 0xF900 && $c <= 0xFAFF) || /* CJK Compatibility Ideographs */
             ($c >= 0xFE10 && $c <= 0xFE19) || /* Vertical forms */
             ($c >= 0xFE30 && $c <= 0xFE6F) || /* CJK Compatibility Forms */
             ($c >= 0xFF00 && $c <= 0xFF60) || /* Fullwidth Forms */
             ($c >= 0xFFE0 && $c <= 0xFFE6) ||
             ($c >= 0x20000 && $c <= 0x2FFFD) ||
             ($c >= 0x30000 && $c <= 0x3FFFD)));
 
       break;
     }
   }
 
   return $len;
 }
 
 
 /**
  * Test if a string contains Chinese, Japanese, or Korean characters.
  *
  * Most languages use spaces to separate words, but these languages do not.
  *
  * @param string String to examine, in UTF8.
  * @return bool True if the string contains Chinese, Japanese, or Korean
  *   characters.
  */
 function phutil_utf8_is_cjk($string) {
   $codepoints = phutil_utf8v_codepoints($string);
 
   foreach ($codepoints as $codepoint) {
     // CJK Unified Ideographs
     if ($codepoint >= 0x4E00 && $codepoint <= 0x9FFF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension A
     if ($codepoint >= 0x3400 && $codepoint <= 0x4DBF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension B
     if ($codepoint >= 0x20000 && $codepoint <= 0x2A6DF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension C
     if ($codepoint >= 0x2A700 && $codepoint <= 0x2B73F) {
       return true;
     }
 
     // CJK Unified Ideographs Extension D
     if ($codepoint >= 0x2B740 && $codepoint <= 0x2B81F) {
       return true;
     }
 
     // CJK Unified Ideographs Extension E
     if ($codepoint >= 0x2B820 && $codepoint <= 0x2CEAF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension F
     if ($codepoint >= 0x2CEB0 && $codepoint <= 0x2EBEF) {
       return true;
     }
 
     // CJK Compatibility Ideographs
     if ($codepoint >= 0xF900 && $codepoint <= 0xFAFF) {
       return true;
     }
   }
 
   return false;
 }
 
 
 /**
  * Split a UTF-8 string into an array of characters. Combining characters are
  * also split.
  *
  * @param string A valid utf-8 string.
  * @param int|null Stop processing after examining this many bytes.
  * @return list  A list of characters in the string.
  */
 function phutil_utf8v($string, $byte_limit = null) {
   $string = phutil_string_cast($string);
 
   $res = array();
   $len = strlen($string);
 
   $ii = 0;
   while ($ii < $len) {
     $byte = $string[$ii];
     if ($byte <= "\x7F") {
       $res[] = $byte;
       $ii += 1;
 
       if ($byte_limit && ($ii >= $byte_limit)) {
         break;
       }
 
       continue;
     } else if ($byte < "\xC0") {
       throw new Exception(
         pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
     } else if ($byte <= "\xDF") {
       $seq_len = 2;
     } else if ($byte <= "\xEF") {
       $seq_len = 3;
     } else if ($byte <= "\xF7") {
       $seq_len = 4;
     } else if ($byte <= "\xFB") {
       $seq_len = 5;
     } else if ($byte <= "\xFD") {
       $seq_len = 6;
     } else {
       throw new Exception(
         pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
     }
 
     if ($ii + $seq_len > $len) {
       throw new Exception(
         pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
     }
     for ($jj = 1; $jj < $seq_len; ++$jj) {
       if ($string[$ii + $jj] >= "\xC0") {
         throw new Exception(
           pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
       }
     }
     $res[] = substr($string, $ii, $seq_len);
     $ii += $seq_len;
 
     if ($byte_limit && ($ii >= $byte_limit)) {
       break;
     }
   }
 
   return $res;
 }
 
 
 /**
  * Split a UTF-8 string into an array of codepoints (as integers).
  *
  * @param   string  A valid UTF-8 string.
  * @return  list    A list of codepoints, as integers.
  */
 function phutil_utf8v_codepoints($string) {
   $str_v = phutil_utf8v($string);
 
   foreach ($str_v as $key => $char) {
     $c = ord($char[0]);
     $v = 0;
 
     if (($c & 0x80) == 0) {
       $v = $c;
     } else if (($c & 0xE0) == 0xC0) {
       $v = (($c & 0x1F) << 6)
          + ((ord($char[1]) & 0x3F));
     } else if (($c & 0xF0) == 0xE0) {
       $v = (($c & 0x0F) << 12)
          + ((ord($char[1]) & 0x3F) << 6)
          + ((ord($char[2]) & 0x3F));
     } else if (($c & 0xF8) == 0xF0) {
       $v = (($c & 0x07) << 18)
          + ((ord($char[1]) & 0x3F) << 12)
          + ((ord($char[2]) & 0x3F) << 6)
          + ((ord($char[3]) & 0x3F));
     } else if (($c & 0xFC) == 0xF8) {
       $v = (($c & 0x03) << 24)
          + ((ord($char[1]) & 0x3F) << 18)
          + ((ord($char[2]) & 0x3F) << 12)
          + ((ord($char[3]) & 0x3F) << 6)
          + ((ord($char[4]) & 0x3F));
     } else if (($c & 0xFE) == 0xFC) {
       $v = (($c & 0x01) << 30)
          + ((ord($char[1]) & 0x3F) << 24)
          + ((ord($char[2]) & 0x3F) << 18)
          + ((ord($char[3]) & 0x3F) << 12)
          + ((ord($char[4]) & 0x3F) << 6)
          + ((ord($char[5]) & 0x3F));
     }
 
     $str_v[$key] = $v;
   }
 
   return $str_v;
 }
 
 
 /**
  * Convert a Unicode codepoint into a UTF8-encoded string.
  *
  * @param int Unicode codepoint.
  * @return string UTF8 encoding.
  */
 function phutil_utf8_encode_codepoint($codepoint) {
   if ($codepoint < 0x80) {
     $r = chr($codepoint);
   } else if ($codepoint < 0x800) {
     $r = chr(0xC0 | (($codepoint >> 6)  & 0x1F)).
          chr(0x80 | (($codepoint)       & 0x3F));
   } else if ($codepoint < 0x10000) {
     $r = chr(0xE0 | (($codepoint >> 12) & 0x0F)).
          chr(0x80 | (($codepoint >> 6)  & 0x3F)).
          chr(0x80 | (($codepoint)       & 0x3F));
   } else if ($codepoint < 0x110000) {
     $r = chr(0xF0 | (($codepoint >> 18) & 0x07)).
          chr(0x80 | (($codepoint >> 12) & 0x3F)).
          chr(0x80 | (($codepoint >> 6)  & 0x3F)).
          chr(0x80 | (($codepoint)       & 0x3F));
   } else {
     throw new Exception(
       pht(
         'Encoding UTF8 codepoint "%s" is not supported.',
         $codepoint));
   }
 
   return $r;
 }
 
 
 /**
  * Hard-wrap a block of UTF-8 text with embedded HTML tags and entities.
  *
  * @param   string An HTML string with tags and entities.
  * @return  list   List of hard-wrapped lines.
  */
 function phutil_utf8_hard_wrap_html($string, $width) {
   $break_here = array();
 
   // Convert the UTF-8 string into a list of UTF-8 characters.
   $vector = phutil_utf8v($string);
   $len = count($vector);
   $char_pos = 0;
   for ($ii = 0; $ii < $len; ++$ii) {
     // An ampersand indicates an HTML entity; consume the whole thing (until
     // ";") but treat it all as one character.
     if ($vector[$ii] == '&') {
       do {
         ++$ii;
       } while ($vector[$ii] != ';');
       ++$char_pos;
     // An "<" indicates an HTML tag, consume the whole thing but don't treat
     // it as a character.
     } else if ($vector[$ii] == '<') {
       do {
         ++$ii;
       } while ($vector[$ii] != '>');
     } else {
       ++$char_pos;
     }
 
     // Keep track of where we need to break the string later.
     if ($char_pos == $width) {
       $break_here[$ii] = true;
       $char_pos = 0;
     }
   }
 
   $result = array();
   $string = '';
   foreach ($vector as $ii => $char) {
     $string .= $char;
     if (isset($break_here[$ii])) {
       $result[] = $string;
       $string = '';
     }
   }
 
   if (strlen($string)) {
     $result[] = $string;
   }
 
   return $result;
 }
 
 /**
   * Hard-wrap a block of UTF-8 text with no embedded HTML tags and entities.
   *
   * @param string A non HTML string
   * @param int Width of the hard-wrapped lines
   * @return list List of hard-wrapped lines.
   */
 function phutil_utf8_hard_wrap($string, $width) {
   $result = array();
 
   $lines = phutil_split_lines($string, $retain_endings = false);
   foreach ($lines as $line) {
 
     // Convert the UTF-8 string into a list of UTF-8 characters.
     $vector = phutil_utf8v($line);
 
     $len = count($vector);
     $buffer = '';
 
     for ($ii = 1; $ii <= $len; ++$ii) {
       $buffer .= $vector[$ii - 1];
       if (($ii % $width) === 0) {
         $result[] = $buffer;
         $buffer = '';
       }
     }
 
     if (strlen($buffer)) {
       $result[] = $buffer;
     }
   }
 
   return $result;
 }
 
 /**
  * Convert a string from one encoding (like ISO-8859-1) to another encoding
  * (like UTF-8).
  *
  * This is primarily a thin wrapper around `mb_convert_encoding()` which checks
  * you have the extension installed, since we try to require the extension
  * only if you actually need it (i.e., you want to work with encodings other
  * than UTF-8).
  *
  * NOTE: This function assumes that the input is in the given source encoding.
  * If it is not, it may not output in the specified target encoding. If you
  * need to perform a hard conversion to UTF-8, use this function in conjunction
  * with @{function:phutil_utf8ize}. We can detect failures caused by invalid
  * encoding names, but `mb_convert_encoding()` fails silently if the
  * encoding name identifies a real encoding but the string is not actually
  * encoded with that encoding.
  *
  * @param string String to re-encode.
  * @param string Target encoding name, like "UTF-8".
  * @param string Source encoding name, like "ISO-8859-1".
  * @return string Input string, with converted character encoding.
  *
  * @phutil-external-symbol function mb_convert_encoding
  */
 function phutil_utf8_convert($string, $to_encoding, $from_encoding) {
   if (!$from_encoding) {
     throw new InvalidArgumentException(
       pht(
         'Attempting to convert a string encoding, but no source encoding '.
         'was provided. Explicitly provide the source encoding.'));
   }
   if (!$to_encoding) {
     throw new InvalidArgumentException(
       pht(
         'Attempting to convert a string encoding, but no target encoding '.
         'was provided. Explicitly provide the target encoding.'));
   }
 
   // Normalize encoding names so we can no-op the very common case of UTF8
   // to UTF8 (or any other conversion where both encodings are identical).
   $to_upper = strtoupper(str_replace('-', '', $to_encoding));
   $from_upper = strtoupper(str_replace('-', '', $from_encoding));
   if ($from_upper == $to_upper) {
     return $string;
   }
 
   if (!function_exists('mb_convert_encoding')) {
     throw new Exception(
       pht(
         "Attempting to convert a string encoding from '%s' to '%s', ".
         "but the '%s' PHP extension is not available. Install %s to ".
         "work with encodings other than UTF-8.",
         $from_encoding,
         $to_encoding,
         'mbstring',
         'mbstring'));
   }
 
   $result = @mb_convert_encoding($string, $to_encoding, $from_encoding);
 
   if ($result === false) {
     $message = error_get_last();
     if ($message) {
       $message = idx($message, 'message', pht('Unknown error.'));
     }
     throw new Exception(
       pht(
         "String conversion from encoding '%s' to encoding '%s' failed: %s",
         $from_encoding,
         $to_encoding,
         $message));
   }
 
   return $result;
 }
 
 
 /**
  * Convert a string to title case in a UTF8-aware way. This function doesn't
  * necessarily do a great job, but the builtin implementation of `ucwords()` can
  * completely destroy inputs, so it just has to be better than that. Similar to
  * @{function:ucwords}.
  *
  * @param   string  UTF-8 input string.
  * @return  string  Input, in some semblance of title case.
  */
 function phutil_utf8_ucwords($str) {
   // NOTE: mb_convert_case() discards uppercase letters in words when converting
   // to title case. For example, it will convert "AAA" into "Aaa", which is
   // undesirable.
 
   $v = phutil_utf8v($str);
   $result = '';
   $last = null;
 
   $ord_a = ord('a');
   $ord_z = ord('z');
   foreach ($v as $c) {
     $convert = false;
     if ($last === null || $last === ' ') {
       $o = ord($c[0]);
       if ($o >= $ord_a && $o <= $ord_z) {
         $convert = true;
       }
     }
 
     if ($convert) {
       $result .= phutil_utf8_strtoupper($c);
     } else {
       $result .= $c;
     }
 
     $last = $c;
   }
 
   return $result;
 }
 
 
 /**
  * Convert a string to lower case in a UTF8-aware way. Similar to
  * @{function:strtolower}.
  *
  * @param   string  UTF-8 input string.
  * @return  string  Input, in some semblance of lower case.
  *
  * @phutil-external-symbol function mb_convert_case
  */
 function phutil_utf8_strtolower($str) {
   if (function_exists('mb_convert_case')) {
     return mb_convert_case($str, MB_CASE_LOWER, 'UTF-8');
   }
 
   static $map;
   if ($map === null) {
     $map = array_combine(
       range('A', 'Z'),
       range('a', 'z'));
   }
 
   return phutil_utf8_strtr($str, $map);
 }
 
 
 /**
  * Convert a string to upper case in a UTF8-aware way. Similar to
  * @{function:strtoupper}.
  *
  * @param   string  UTF-8 input string.
  * @return  string  Input, in some semblance of upper case.
  *
  * @phutil-external-symbol function mb_convert_case
  */
 function phutil_utf8_strtoupper($str) {
   if (function_exists('mb_convert_case')) {
     return mb_convert_case($str, MB_CASE_UPPER, 'UTF-8');
   }
 
   static $map;
   if ($map === null) {
     $map = array_combine(
       range('a', 'z'),
       range('A', 'Z'));
   }
 
   return phutil_utf8_strtr($str, $map);
 }
 
 
 /**
  * Replace characters in a string in a UTF-aware way. Similar to
  * @{function:strtr}.
  *
  * @param   string              UTF-8 input string.
  * @param   map<string, string> Map of characters to replace.
  * @return  string              Input with translated characters.
  */
 function phutil_utf8_strtr($str, array $map) {
   $v = phutil_utf8v($str);
   $result = '';
   foreach ($v as $c) {
     if (isset($map[$c])) {
       $result .= $map[$c];
     } else {
       $result .= $c;
     }
   }
 
   return $result;
 }
 
 /**
  * Determine if a given unicode character is a combining character or not.
  *
  * @param   string              A single unicode character.
  * @return  boolean             True or false.
  */
 function phutil_utf8_is_combining_character($character) {
   $components = phutil_utf8v_codepoints($character);
 
   // Combining Diacritical Marks (0300 - 036F).
   // Combining Diacritical Marks Supplement (1DC0 - 1DFF).
   // Combining Diacritical Marks for Symbols (20D0 - 20FF).
   // Combining Half Marks (FE20 - FE2F).
 
   foreach ($components as $codepoint) {
     if ($codepoint >= 0x0300 && $codepoint <= 0x036F ||
          $codepoint >= 0x1DC0 && $codepoint <= 0x1DFF ||
          $codepoint >= 0x20D0 && $codepoint <= 0x20FF ||
          $codepoint >= 0xFE20 && $codepoint <= 0xFE2F) {
       return true;
     }
   }
 
   return false;
 }
 
 
 /**
  * Split a UTF-8 string into an array of characters. Combining characters
  * are not split.
  *
  * @param string A valid utf-8 string.
  * @return list  A list of characters in the string.
  */
 function phutil_utf8v_combined($string) {
   $components = phutil_utf8v($string);
   return phutil_utf8v_combine_characters($components);
 }
 
 
 /**
  * Merge combining characters in a UTF-8 string.
  *
  * This is a low-level method which can allow other operations to do less work.
  * If you have a string, call @{method:phutil_utf8v_combined} instead.
  *
  * @param list List of UTF-8 characters.
  * @return list List of UTF-8 strings with combining characters merged.
  */
 function phutil_utf8v_combine_characters(array $characters) {
   if (!$characters) {
     return array();
   }
 
   // If the first character in the string is a combining character,
   // start with a space.
   if (phutil_utf8_is_combining_character($characters[0])) {
     $buf = ' ';
   } else {
     $buf = null;
   }
 
   $parts = array();
   foreach ($characters as $character) {
     if (!isset($character[1])) {
       // This an optimization: there are no one-byte combining characters,
       // so we can just pass these through unmodified.
       $is_combining = false;
     } else {
       $is_combining = phutil_utf8_is_combining_character($character);
     }
 
     if ($is_combining) {
       $buf .= $character;
     } else {
       if ($buf !== null) {
         $parts[] = $buf;
       }
       $buf = $character;
     }
   }
 
   $parts[] = $buf;
 
   return $parts;
 }
 
 
 /**
  * Return the current system locale setting (LC_ALL).
  *
  * @return string Current system locale setting.
  */
 function phutil_get_system_locale() {
   $locale = setlocale(LC_ALL, 0);
 
   if ($locale === false) {
     throw new Exception(
       pht(
         'Unable to determine current system locale (call to '.
         '"setlocale(LC_ALL, 0)" failed).'));
   }
 
   return $locale;
 }
 
 
 /**
  * Test if a system locale (LC_ALL) is available on the system.
  *
  * @param string Locale name like "en_US.UTF-8".
  * @return bool True if the locale is available.
  */
 function phutil_is_system_locale_available($locale) {
   $old_locale = phutil_get_system_locale();
   $is_available = @setlocale(LC_ALL, $locale);
   setlocale(LC_ALL, $old_locale);
 
   return ($is_available !== false);
 }
 
 
 /**
  * Set the system locale (LC_ALL) to a particular value.
  *
  * @param string New locale setting.
  * @return void
  */
 function phutil_set_system_locale($locale) {
   $ok = @setlocale(LC_ALL, $locale);
   if (!$ok) {
     throw new Exception(
       pht(
         'Failed to set system locale (to "%s").',
         $locale));
   }
 }
diff --git a/src/utils/utils.php b/src/utils/utils.php
index cbc4d5fb..3bcaab02 100644
--- a/src/utils/utils.php
+++ b/src/utils/utils.php
@@ -1,2096 +1,2221 @@
 <?php
 
 /**
  * Identity function, returns its argument unmodified.
  *
  * This is useful almost exclusively as a workaround to an oddity in the PHP
  * grammar -- this is a syntax error:
  *
  *    COUNTEREXAMPLE
  *    new Thing()->doStuff();
  *
  * ...but this works fine:
  *
  *    id(new Thing())->doStuff();
  *
  * @param   wild Anything.
  * @return  wild Unmodified argument.
  */
 function id($x) {
   return $x;
 }
 
 
 /**
  * Access an array index, retrieving the value stored there if it exists or
  * a default if it does not. This function allows you to concisely access an
  * index which may or may not exist without raising a warning.
  *
  * @param   array   Array to access.
  * @param   scalar  Index to access in the array.
  * @param   wild    Default value to return if the key is not present in the
  *                  array.
  * @return  wild    If `$array[$key]` exists, that value is returned. If not,
  *                  $default is returned without raising a warning.
  */
 function idx(array $array, $key, $default = null) {
   // isset() is a micro-optimization - it is fast but fails for null values.
   if (isset($array[$key])) {
     return $array[$key];
   }
 
   // Comparing $default is also a micro-optimization.
   if ($default === null || array_key_exists($key, $array)) {
     return null;
   }
 
   return $default;
 }
 
 
 /**
  * Access a sequence of array indexes, retrieving a deeply nested value if
  * it exists or a default if it does not.
  *
  * For example, `idxv($dict, array('a', 'b', 'c'))` accesses the key at
  * `$dict['a']['b']['c']`, if it exists. If it does not, or any intermediate
  * value is not itself an array, it returns the defualt value.
  *
  * @param array Array to access.
  * @param list<string> List of keys to access, in sequence.
  * @param wild Default value to return.
  * @return wild Accessed value, or default if the value is not accessible.
  */
 function idxv(array $map, array $path, $default = null) {
   if (!$path) {
     return $default;
   }
 
   $last = last($path);
   $path = array_slice($path, 0, -1);
 
   $cursor = $map;
   foreach ($path as $key) {
     $cursor = idx($cursor, $key);
     if (!is_array($cursor)) {
       return $default;
     }
   }
 
   return idx($cursor, $last, $default);
 }
 
 
 /**
  * Call a method on a list of objects. Short for "method pull", this function
  * works just like @{function:ipull}, except that it operates on a list of
  * objects instead of a list of arrays. This function simplifies a common type
  * of mapping operation:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $key => $object) {
  *      $names[$key] = $object->getName();
  *    }
  *
  * You can express this more concisely with mpull():
  *
  *    $names = mpull($objects, 'getName');
  *
  * mpull() takes a third argument, which allows you to do the same but for
  * the array's keys:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $object) {
  *      $names[$object->getID()] = $object->getName();
  *    }
  *
  * This is the mpull version():
  *
  *    $names = mpull($objects, 'getName', 'getID');
  *
  * If you pass ##null## as the second argument, the objects will be preserved:
  *
  *    COUNTEREXAMPLE
  *    $id_map = array();
  *    foreach ($objects as $object) {
  *      $id_map[$object->getID()] = $object;
  *    }
  *
  * With mpull():
  *
  *    $id_map = mpull($objects, null, 'getID');
  *
  * See also @{function:ipull}, which works similarly but accesses array indexes
  * instead of calling methods.
  *
  * @param   list          Some list of objects.
  * @param   string|null   Determines which **values** will appear in the result
  *                        array. Use a string like 'getName' to store the
  *                        value of calling the named method in each value, or
  *                        ##null## to preserve the original objects.
  * @param   string|null   Determines how **keys** will be assigned in the result
  *                        array. Use a string like 'getID' to use the result
  *                        of calling the named method as each object's key, or
  *                        `null` to preserve the original keys.
  * @return  dict          A dictionary with keys and values derived according
  *                        to whatever you passed as `$method` and `$key_method`.
  */
 function mpull(array $list, $method, $key_method = null) {
   $result = array();
   foreach ($list as $key => $object) {
     if ($key_method !== null) {
       $key = $object->$key_method();
     }
     if ($method !== null) {
       $value = $object->$method();
     } else {
       $value = $object;
     }
     $result[$key] = $value;
   }
   return $result;
 }
 
 
 /**
  * Access a property on a list of objects. Short for "property pull", this
  * function works just like @{function:mpull}, except that it accesses object
  * properties instead of methods. This function simplifies a common type of
  * mapping operation:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $key => $object) {
  *      $names[$key] = $object->name;
  *    }
  *
  * You can express this more concisely with ppull():
  *
  *    $names = ppull($objects, 'name');
  *
  * ppull() takes a third argument, which allows you to do the same but for
  * the array's keys:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $object) {
  *      $names[$object->id] = $object->name;
  *    }
  *
  * This is the ppull version():
  *
  *    $names = ppull($objects, 'name', 'id');
  *
  * If you pass ##null## as the second argument, the objects will be preserved:
  *
  *    COUNTEREXAMPLE
  *    $id_map = array();
  *    foreach ($objects as $object) {
  *      $id_map[$object->id] = $object;
  *    }
  *
  * With ppull():
  *
  *    $id_map = ppull($objects, null, 'id');
  *
  * See also @{function:mpull}, which works similarly but calls object methods
  * instead of accessing object properties.
  *
  * @param   list          Some list of objects.
  * @param   string|null   Determines which **values** will appear in the result
  *                        array. Use a string like 'name' to store the value of
  *                        accessing the named property in each value, or
  *                        `null` to preserve the original objects.
  * @param   string|null   Determines how **keys** will be assigned in the result
  *                        array. Use a string like 'id' to use the result of
  *                        accessing the named property as each object's key, or
  *                        `null` to preserve the original keys.
  * @return  dict          A dictionary with keys and values derived according
  *                        to whatever you passed as `$property` and
  *                        `$key_property`.
  */
 function ppull(array $list, $property, $key_property = null) {
   $result = array();
   foreach ($list as $key => $object) {
     if ($key_property !== null) {
       $key = $object->$key_property;
     }
     if ($property !== null) {
       $value = $object->$property;
     } else {
       $value = $object;
     }
     $result[$key] = $value;
   }
   return $result;
 }
 
 
 /**
  * Choose an index from a list of arrays. Short for "index pull", this function
  * works just like @{function:mpull}, except that it operates on a list of
  * arrays and selects an index from them instead of operating on a list of
  * objects and calling a method on them.
  *
  * This function simplifies a common type of mapping operation:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($list as $key => $dict) {
  *      $names[$key] = $dict['name'];
  *    }
  *
  * With ipull():
  *
  *    $names = ipull($list, 'name');
  *
  * See @{function:mpull} for more usage examples.
  *
  * @param   list          Some list of arrays.
  * @param   scalar|null   Determines which **values** will appear in the result
  *                        array. Use a scalar to select that index from each
  *                        array, or null to preserve the arrays unmodified as
  *                        values.
  * @param   scalar|null   Determines which **keys** will appear in the result
  *                        array. Use a scalar to select that index from each
  *                        array, or null to preserve the array keys.
  * @return  dict          A dictionary with keys and values derived according
  *                        to whatever you passed for `$index` and `$key_index`.
  */
 function ipull(array $list, $index, $key_index = null) {
   $result = array();
   foreach ($list as $key => $array) {
     if ($key_index !== null) {
       $key = $array[$key_index];
     }
     if ($index !== null) {
       $value = $array[$index];
     } else {
       $value = $array;
     }
     $result[$key] = $value;
   }
   return $result;
 }
 
 
 /**
  * Group a list of objects by the result of some method, similar to how
  * GROUP BY works in an SQL query. This function simplifies grouping objects
  * by some property:
  *
  *    COUNTEREXAMPLE
  *    $animals_by_species = array();
  *    foreach ($animals as $animal) {
  *      $animals_by_species[$animal->getSpecies()][] = $animal;
  *    }
  *
  * This can be expressed more tersely with mgroup():
  *
  *    $animals_by_species = mgroup($animals, 'getSpecies');
  *
  * In either case, the result is a dictionary which maps species (e.g., like
  * "dog") to lists of animals with that property, so all the dogs are grouped
  * together and all the cats are grouped together, or whatever super
  * businessesey thing is actually happening in your problem domain.
  *
  * See also @{function:igroup}, which works the same way but operates on
  * array indexes.
  *
  * @param   list    List of objects to group by some property.
  * @param   string  Name of a method, like 'getType', to call on each object
  *                  in order to determine which group it should be placed into.
  * @param   ...     Zero or more additional method names, to subgroup the
  *                  groups.
  * @return  dict    Dictionary mapping distinct method returns to lists of
  *                  all objects which returned that value.
  */
 function mgroup(array $list, $by /* , ... */) {
   $map = mpull($list, $by);
 
   $groups = array();
   foreach ($map as $group) {
     // Can't array_fill_keys() here because 'false' gets encoded wrong.
     $groups[$group] = array();
   }
 
   foreach ($map as $key => $group) {
     $groups[$group][$key] = $list[$key];
   }
 
   $args = func_get_args();
   $args = array_slice($args, 2);
   if ($args) {
     array_unshift($args, null);
     foreach ($groups as $group_key => $grouped) {
       $args[0] = $grouped;
       $groups[$group_key] = call_user_func_array('mgroup', $args);
     }
   }
 
   return $groups;
 }
 
 
 /**
  * Group a list of arrays by the value of some index. This function is the same
  * as @{function:mgroup}, except it operates on the values of array indexes
  * rather than the return values of method calls.
  *
  * @param   list    List of arrays to group by some index value.
  * @param   string  Name of an index to select from each array in order to
  *                  determine which group it should be placed into.
  * @param   ...     Zero or more additional indexes names, to subgroup the
  *                  groups.
  * @return  dict    Dictionary mapping distinct index values to lists of
  *                  all objects which had that value at the index.
  */
 function igroup(array $list, $by /* , ... */) {
   $map = ipull($list, $by);
 
   $groups = array();
   foreach ($map as $group) {
     $groups[$group] = array();
   }
 
   foreach ($map as $key => $group) {
     $groups[$group][$key] = $list[$key];
   }
 
   $args = func_get_args();
   $args = array_slice($args, 2);
   if ($args) {
     array_unshift($args, null);
     foreach ($groups as $group_key => $grouped) {
       $args[0] = $grouped;
       $groups[$group_key] = call_user_func_array('igroup', $args);
     }
   }
 
   return $groups;
 }
 
 
 /**
  * Sort a list of objects by the return value of some method. In PHP, this is
  * often vastly more efficient than `usort()` and similar.
  *
  *    // Sort a list of Duck objects by name.
  *    $sorted = msort($ducks, 'getName');
  *
  * It is usually significantly more efficient to define an ordering method
  * on objects and call `msort()` than to write a comparator. It is often more
  * convenient, as well.
  *
  * NOTE: This method does not take the list by reference; it returns a new list.
  *
  * @param   list    List of objects to sort by some property.
  * @param   string  Name of a method to call on each object; the return values
  *                  will be used to sort the list.
  * @return  list    Objects ordered by the return values of the method calls.
  */
 function msort(array $list, $method) {
   $surrogate = mpull($list, $method);
 
   // See T13303. A "PhutilSortVector" is technically a sortable object, so
   // a method which returns a "PhutilSortVector" is suitable for use with
   // "msort()". However, it's almost certain that the caller intended to use
   // "msortv()", not "msort()", and forgot to add a "v". Treat this as an error.
 
   if ($surrogate) {
     $item = head($surrogate);
     if ($item instanceof PhutilSortVector) {
       throw new Exception(
         pht(
           'msort() was passed a method ("%s") which returns '.
           '"PhutilSortVector" objects. Use "msortv()", not "msort()", to '.
           'sort a list which produces vectors.',
           $method));
     }
   }
 
   asort($surrogate);
 
   $result = array();
   foreach ($surrogate as $key => $value) {
     $result[$key] = $list[$key];
   }
 
   return $result;
 }
 
 
 /**
  * Sort a list of objects by a sort vector.
  *
  * This sort is stable, well-behaved, and more efficient than `usort()`.
  *
  * @param list List of objects to sort.
  * @param string Name of a method to call on each object. The method must
  *   return a @{class:PhutilSortVector}.
  * @return list Objects ordered by the vectors.
  */
 function msortv(array $list, $method) {
   return msortv_internal($list, $method, SORT_STRING);
 }
 
 function msortv_natural(array $list, $method) {
   return msortv_internal($list, $method, SORT_NATURAL | SORT_FLAG_CASE);
 }
 
 function msortv_internal(array $list, $method, $flags) {
   $surrogate = mpull($list, $method);
 
   $index = 0;
   foreach ($surrogate as $key => $value) {
     if (!($value instanceof PhutilSortVector)) {
       throw new Exception(
         pht(
           'Objects passed to "%s" must return sort vectors (objects of '.
           'class "%s") from the specified method ("%s"). One object (with '.
           'key "%s") did not.',
           'msortv()',
           'PhutilSortVector',
           $method,
           $key));
     }
 
     // Add the original index to keep the sort stable.
     $value->addInt($index++);
 
     $surrogate[$key] = (string)$value;
   }
 
   asort($surrogate, $flags);
 
   $result = array();
   foreach ($surrogate as $key => $value) {
     $result[$key] = $list[$key];
   }
 
   return $result;
 }
 
 
 /**
  * Sort a list of arrays by the value of some index. This method is identical to
  * @{function:msort}, but operates on a list of arrays instead of a list of
  * objects.
  *
  * @param   list    List of arrays to sort by some index value.
  * @param   string  Index to access on each object; the return values
  *                  will be used to sort the list.
  * @return  list    Arrays ordered by the index values.
  */
 function isort(array $list, $index) {
   $surrogate = ipull($list, $index);
 
   asort($surrogate);
 
   $result = array();
   foreach ($surrogate as $key => $value) {
     $result[$key] = $list[$key];
   }
 
   return $result;
 }
 
 
 /**
  * Filter a list of objects by executing a method across all the objects and
  * filter out the ones with empty() results. this function works just like
  * @{function:ifilter}, except that it operates on a list of objects instead
  * of a list of arrays.
  *
  * For example, to remove all objects with no children from a list, where
  * 'hasChildren' is a method name, do this:
  *
  *   mfilter($list, 'hasChildren');
  *
  * The optional third parameter allows you to negate the operation and filter
  * out nonempty objects. To remove all objects that DO have children, do this:
  *
  *   mfilter($list, 'hasChildren', true);
  *
  * @param  array        List of objects to filter.
  * @param  string       A method name.
  * @param  bool         Optionally, pass true to drop objects which pass the
  *                      filter instead of keeping them.
  * @return array        List of objects which pass the filter.
  */
 function mfilter(array $list, $method, $negate = false) {
   if (!is_string($method)) {
     throw new InvalidArgumentException(pht('Argument method is not a string.'));
   }
 
   $result = array();
   foreach ($list as $key => $object) {
     $value = $object->$method();
 
     if (!$negate) {
       if (!empty($value)) {
         $result[$key] = $object;
       }
     } else {
       if (empty($value)) {
         $result[$key] = $object;
       }
     }
   }
 
   return $result;
 }
 
 
 /**
  * Filter a list of arrays by removing the ones with an empty() value for some
  * index. This function works just like @{function:mfilter}, except that it
  * operates on a list of arrays instead of a list of objects.
  *
  * For example, to remove all arrays without value for key 'username', do this:
  *
  *   ifilter($list, 'username');
  *
  * The optional third parameter allows you to negate the operation and filter
  * out nonempty arrays. To remove all arrays that DO have value for key
  * 'username', do this:
  *
  *   ifilter($list, 'username', true);
  *
  * @param  array        List of arrays to filter.
  * @param  scalar       The index.
  * @param  bool         Optionally, pass true to drop arrays which pass the
  *                      filter instead of keeping them.
  * @return array        List of arrays which pass the filter.
  */
 function ifilter(array $list, $index, $negate = false) {
   if (!is_scalar($index)) {
     throw new InvalidArgumentException(pht('Argument index is not a scalar.'));
   }
 
   $result = array();
   if (!$negate) {
     foreach ($list as $key => $array) {
       if (!empty($array[$index])) {
         $result[$key] = $array;
       }
     }
   } else {
     foreach ($list as $key => $array) {
       if (empty($array[$index])) {
         $result[$key] = $array;
       }
     }
   }
 
   return $result;
 }
 
 
 /**
  * Selects a list of keys from an array, returning a new array with only the
  * key-value pairs identified by the selected keys, in the specified order.
  *
  * Note that since this function orders keys in the result according to the
  * order they appear in the list of keys, there are effectively two common
  * uses: either reducing a large dictionary to a smaller one, or changing the
  * key order on an existing dictionary.
  *
  * @param  dict    Dictionary of key-value pairs to select from.
  * @param  list    List of keys to select.
  * @return dict    Dictionary of only those key-value pairs where the key was
  *                 present in the list of keys to select. Ordering is
  *                 determined by the list order.
  */
 function array_select_keys(array $dict, array $keys) {
   $result = array();
   foreach ($keys as $key) {
     if (array_key_exists($key, $dict)) {
       $result[$key] = $dict[$key];
     }
   }
   return $result;
 }
 
 
 /**
  * Checks if all values of array are instances of the passed class. Throws
  * `InvalidArgumentException` if it isn't true for any value.
  *
  * @param  array
  * @param  string  Name of the class or 'array' to check arrays.
  * @return array   Returns passed array.
  */
 function assert_instances_of(array $arr, $class) {
   $is_array = !strcasecmp($class, 'array');
 
   foreach ($arr as $key => $object) {
     if ($is_array) {
       if (!is_array($object)) {
         $given = gettype($object);
         throw new InvalidArgumentException(
           pht(
             "Array item with key '%s' must be of type array, %s given.",
             $key,
             $given));
       }
 
     } else if (!($object instanceof $class)) {
       $given = gettype($object);
       if (is_object($object)) {
         $given = pht('instance of %s', get_class($object));
       }
       throw new InvalidArgumentException(
         pht(
           "Array item with key '%s' must be an instance of %s, %s given.",
           $key,
           $class,
           $given));
     }
   }
 
   return $arr;
 }
 
 /**
  * Assert that two arrays have the exact same keys, in any order.
  *
  * @param map Array with expected keys.
  * @param map Array with actual keys.
  * @return void
  */
 function assert_same_keys(array $expect, array $actual) {
   foreach ($expect as $key => $value) {
     if (isset($actual[$key]) || array_key_exists($key, $actual)) {
       continue;
     }
 
     throw new InvalidArgumentException(
       pht(
         'Expected to find key "%s", but it is not present.',
         $key));
 
   }
 
   foreach ($actual as $key => $value) {
     if (isset($expect[$key]) || array_key_exists($key, $expect)) {
       continue;
     }
 
     throw new InvalidArgumentException(
       pht(
         'Found unexpected surplus key "%s" where no such key was expected.',
         $key));
   }
 }
 
 /**
  * Assert that passed data can be converted to string.
  *
  * @param  string    Assert that this data is valid.
  * @return void
  *
  * @task   assert
  */
 function assert_stringlike($parameter) {
   switch (gettype($parameter)) {
     case 'string':
     case 'NULL':
     case 'boolean':
     case 'double':
     case 'integer':
       return;
     case 'object':
       if (method_exists($parameter, '__toString')) {
         return;
       }
       break;
     case 'array':
     case 'resource':
     case 'unknown type':
     default:
       break;
   }
 
   throw new InvalidArgumentException(
     pht(
       'Argument must be scalar or object which implements %s!',
       '__toString()'));
 }
 
 /**
  * Returns the first argument which is not strictly null, or `null` if there
  * are no such arguments. Identical to the MySQL function of the same name.
  *
  * @param  ...         Zero or more arguments of any type.
  * @return mixed       First non-`null` arg, or null if no such arg exists.
  */
 function coalesce(/* ... */) {
   $args = func_get_args();
   foreach ($args as $arg) {
     if ($arg !== null) {
       return $arg;
     }
   }
   return null;
 }
 
 
 /**
  * Similar to @{function:coalesce}, but less strict: returns the first
  * non-`empty()` argument, instead of the first argument that is strictly
  * non-`null`. If no argument is nonempty, it returns the last argument. This
  * is useful idiomatically for setting defaults:
  *
  *   $display_name = nonempty($user_name, $full_name, "Anonymous");
  *
  * @param  ...         Zero or more arguments of any type.
  * @return mixed       First non-`empty()` arg, or last arg if no such arg
  *                     exists, or null if you passed in zero args.
  */
 function nonempty(/* ... */) {
   $args = func_get_args();
   $result = null;
   foreach ($args as $arg) {
     $result = $arg;
     if ($arg) {
       break;
     }
   }
   return $result;
 }
 
 
 /**
  * Invokes the "new" operator with a vector of arguments. There is no way to
  * `call_user_func_array()` on a class constructor, so you can instead use this
  * function:
  *
  *   $obj = newv($class_name, $argv);
  *
  * That is, these two statements are equivalent:
  *
  *   $pancake = new Pancake('Blueberry', 'Maple Syrup', true);
  *   $pancake = newv('Pancake', array('Blueberry', 'Maple Syrup', true));
  *
  * DO NOT solve this problem in other, more creative ways! Three popular
  * alternatives are:
  *
  *   - Build a fake serialized object and unserialize it.
  *   - Invoke the constructor twice.
  *   - just use `eval()` lol
  *
  * These are really bad solutions to the problem because they can have side
  * effects (e.g., __wakeup()) and give you an object in an otherwise impossible
  * state. Please endeavor to keep your objects in possible states.
  *
  * If you own the classes you're doing this for, you should consider whether
  * or not restructuring your code (for instance, by creating static
  * construction methods) might make it cleaner before using `newv()`. Static
  * constructors can be invoked with `call_user_func_array()`, and may give your
  * class a cleaner and more descriptive API.
  *
  * @param  string  The name of a class.
  * @param  list    Array of arguments to pass to its constructor.
  * @return obj     A new object of the specified class, constructed by passing
  *                 the argument vector to its constructor.
  */
 function newv($class_name, array $argv) {
   $reflector = new ReflectionClass($class_name);
   if ($argv) {
     return $reflector->newInstanceArgs($argv);
   } else {
     return $reflector->newInstance();
   }
 }
 
 
 /**
  * Returns the first element of an array. Exactly like reset(), but doesn't
  * choke if you pass it some non-referenceable value like the return value of
  * a function.
  *
  * @param    array Array to retrieve the first element from.
  * @return   wild  The first value of the array.
  */
 function head(array $arr) {
   return reset($arr);
 }
 
 /**
  * Returns the last element of an array. This is exactly like `end()` except
  * that it won't warn you if you pass some non-referencable array to
  * it -- e.g., the result of some other array operation.
  *
  * @param    array Array to retrieve the last element from.
  * @return   wild  The last value of the array.
  */
 function last(array $arr) {
   return end($arr);
 }
 
 /**
  * Returns the first key of an array.
  *
  * @param    array       Array to retrieve the first key from.
  * @return   int|string  The first key of the array.
  */
 function head_key(array $arr) {
   reset($arr);
   return key($arr);
 }
 
 /**
  * Returns the last key of an array.
  *
  * @param    array       Array to retrieve the last key from.
  * @return   int|string  The last key of the array.
  */
 function last_key(array $arr) {
   end($arr);
   return key($arr);
 }
 
 /**
  * Merge a vector of arrays performantly. This has the same semantics as
  * array_merge(), so these calls are equivalent:
  *
  *   array_merge($a, $b, $c);
  *   array_mergev(array($a, $b, $c));
  *
  * However, when you have a vector of arrays, it is vastly more performant to
  * merge them with this function than by calling array_merge() in a loop,
  * because using a loop generates an intermediary array on each iteration.
  *
  * @param list Vector of arrays to merge.
  * @return list Arrays, merged with array_merge() semantics.
  */
 function array_mergev(array $arrayv) {
   if (!$arrayv) {
     return array();
   }
 
   foreach ($arrayv as $key => $item) {
     if (!is_array($item)) {
       throw new InvalidArgumentException(
         pht(
           'Expected all items passed to "array_mergev()" to be arrays, but '.
           'argument with key "%s" has type "%s".',
           $key,
           gettype($item)));
     }
   }
 
   // See T13588. In PHP8, "call_user_func_array()" will attempt to use
   // "unnatural" array keys as named parameters, and then fail because
   // "array_merge()" does not accept named parameters . Guarantee the list is
   // a "natural" list to avoid this.
   $arrayv = array_values($arrayv);
 
   return call_user_func_array('array_merge', $arrayv);
 }
 
 
 /**
  * Split a corpus of text into lines. This function splits on "\n", "\r\n", or
  * a mixture of any of them.
  *
  * NOTE: This function does not treat "\r" on its own as a newline because none
  * of SVN, Git or Mercurial do on any OS.
  *
  * @param string Block of text to be split into lines.
  * @param bool If true, retain line endings in result strings.
  * @return list List of lines.
  *
  * @phutil-external-symbol class PhutilSafeHTML
  * @phutil-external-symbol function phutil_safe_html
  */
 function phutil_split_lines($corpus, $retain_endings = true) {
   if (!strlen($corpus)) {
     return array('');
   }
 
   // Split on "\r\n" or "\n".
   if ($retain_endings) {
     $lines = preg_split('/(?<=\n)/', $corpus);
   } else {
     $lines = preg_split('/\r?\n/', $corpus);
   }
 
   // If the text ends with "\n" or similar, we'll end up with an empty string
   // at the end; discard it.
   if (end($lines) == '') {
     array_pop($lines);
   }
 
   if ($corpus instanceof PhutilSafeHTML) {
     foreach ($lines as $key => $line) {
       $lines[$key] = phutil_safe_html($line);
     }
     return $lines;
   }
 
   return $lines;
 }
 
 
 /**
  * Simplifies a common use of `array_combine()`. Specifically, this:
  *
  *   COUNTEREXAMPLE:
  *   if ($list) {
  *     $result = array_combine($list, $list);
  *   } else {
  *     // Prior to PHP 5.4, array_combine() failed if given empty arrays.
  *     $result = array();
  *   }
  *
  * ...is equivalent to this:
  *
  *   $result = array_fuse($list);
  *
  * @param   list  List of scalars.
  * @return  dict  Dictionary with inputs mapped to themselves.
  */
 function array_fuse(array $list) {
   if ($list) {
     return array_combine($list, $list);
   }
   return array();
 }
 
 
 /**
  * Add an element between every two elements of some array. That is, given a
  * list `A, B, C, D`, and some element to interleave, `x`, this function returns
  * `A, x, B, x, C, x, D`. This works like `implode()`, but does not concatenate
  * the list into a string. In particular:
  *
  *   implode('', array_interleave($x, $list));
  *
  * ...is equivalent to:
  *
  *   implode($x, $list);
  *
  * This function does not preserve keys.
  *
  * @param wild  Element to interleave.
  * @param list  List of elements to be interleaved.
  * @return list Original list with the new element interleaved.
  */
 function array_interleave($interleave, array $array) {
   $result = array();
   foreach ($array as $item) {
     $result[] = $item;
     $result[] = $interleave;
   }
   array_pop($result);
   return $result;
 }
 
 function phutil_is_windows() {
   // We can also use PHP_OS, but that's kind of sketchy because it returns
   // "WINNT" for Windows 7 and "Darwin" for Mac OS X. Practically, testing for
   // DIRECTORY_SEPARATOR is more straightforward.
   return (DIRECTORY_SEPARATOR != '/');
 }
 
 function phutil_is_hiphop_runtime() {
   return (array_key_exists('HPHP', $_ENV) && $_ENV['HPHP'] === 1);
 }
 
 /**
  * Converts a string to a loggable one, with unprintables and newlines escaped.
  *
  * @param string  Any string.
  * @return string String with control and newline characters escaped, suitable
  *                for printing on a single log line.
  */
 function phutil_loggable_string($string) {
   if (preg_match('/^[\x20-\x7E]+$/', $string)) {
     return $string;
   }
 
   $result = '';
 
   static $c_map = array(
     '\\' => '\\\\',
     "\n" => '\\n',
     "\r" => '\\r',
     "\t" => '\\t',
   );
 
   $len = strlen($string);
   for ($ii = 0; $ii < $len; $ii++) {
     $c = $string[$ii];
     if (isset($c_map[$c])) {
       $result .= $c_map[$c];
     } else {
       $o = ord($c);
       if ($o < 0x20 || $o >= 0x7F) {
         $result .= '\\x'.sprintf('%02X', $o);
       } else {
         $result .= $c;
       }
     }
   }
 
   return $result;
 }
 
 
 /**
  * Perform an `fwrite()` which distinguishes between EAGAIN and EPIPE.
  *
  * PHP's `fwrite()` is broken, and never returns `false` for writes to broken
  * nonblocking pipes: it always returns 0, and provides no straightforward
  * mechanism for distinguishing between EAGAIN (buffer is full, can't write any
  * more right now) and EPIPE or similar (no write will ever succeed).
  *
  * See: https://bugs.php.net/bug.php?id=39598
  *
  * If you call this method instead of `fwrite()`, it will attempt to detect
  * when a zero-length write is caused by EAGAIN and return `0` only if the
  * write really should be retried.
  *
  * @param resource  Socket or pipe stream.
  * @param string    Bytes to write.
  * @return bool|int Number of bytes written, or `false` on any error (including
  *                  errors which `fwrite()` can not detect, like a broken pipe).
  */
 function phutil_fwrite_nonblocking_stream($stream, $bytes) {
   if (!strlen($bytes)) {
     return 0;
   }
 
   $result = @fwrite($stream, $bytes);
   if ($result !== 0) {
     // In cases where some bytes are witten (`$result > 0`) or
     // an error occurs (`$result === false`), the behavior of fwrite() is
     // correct. We can return the value as-is.
     return $result;
   }
 
   // If we make it here, we performed a 0-length write. Try to distinguish
   // between EAGAIN and EPIPE. To do this, we're going to `stream_select()`
   // the stream, write to it again if PHP claims that it's writable, and
   // consider the pipe broken if the write fails.
 
   // (Signals received during the "fwrite()" do not appear to affect anything,
   // see D20083.)
 
   $read = array();
   $write = array($stream);
   $except = array();
 
   $result = @stream_select($read, $write, $except, 0);
   if ($result === false) {
     // See T13243. If the select is interrupted by a signal, it may return
     // "false" indicating an underlying EINTR condition. In this case, the
     // results (notably, "$write") are not usable because "stream_select()"
     // didn't update them.
 
     // In this case, treat this stream as blocked and tell the caller to
     // retry, since EINTR is the only condition we're currently aware of that
     // can cause "fwrite()" to return "0" and "stream_select()" to return
     // "false" on the same stream.
     return 0;
   }
 
   if (!$write) {
     // The stream isn't writable, so we conclude that it probably really is
     // blocked and the underlying error was EAGAIN. Return 0 to indicate that
     // no data could be written yet.
     return 0;
   }
 
   // If we make it here, PHP **just** claimed that this stream is writable, so
   // perform a write. If the write also fails, conclude that these failures are
   // EPIPE or some other permanent failure.
   $result = @fwrite($stream, $bytes);
   if ($result !== 0) {
     // The write worked or failed explicitly. This value is fine to return.
     return $result;
   }
 
   // We performed a 0-length write, were told that the stream was writable, and
   // then immediately performed another 0-length write. Conclude that the pipe
   // is broken and return `false`.
   return false;
 }
 
 
 /**
  * Convert a human-readable unit description into a numeric one. This function
  * allows you to replace this:
  *
  *   COUNTEREXAMPLE
  *   $ttl = (60 * 60 * 24 * 30); // 30 days
  *
  * ...with this:
  *
  *   $ttl = phutil_units('30 days in seconds');
  *
  * ...which is self-documenting and difficult to make a mistake with.
  *
  * @param   string  Human readable description of a unit quantity.
  * @return  int     Quantity of specified unit.
  */
 function phutil_units($description) {
   $matches = null;
   if (!preg_match('/^(\d+) (\w+) in (\w+)$/', $description, $matches)) {
     throw new InvalidArgumentException(
       pht(
         'Unable to parse unit specification (expected a specification in the '.
         'form "%s"): %s',
         '5 days in seconds',
         $description));
   }
 
   $quantity = (int)$matches[1];
   $src_unit = $matches[2];
   $dst_unit = $matches[3];
 
   $is_divisor = false;
 
   switch ($dst_unit) {
     case 'seconds':
       switch ($src_unit) {
         case 'second':
         case 'seconds':
           $factor = 1;
           break;
         case 'minute':
         case 'minutes':
           $factor = 60;
           break;
         case 'hour':
         case 'hours':
           $factor = 60 * 60;
           break;
         case 'day':
         case 'days':
           $factor = 60 * 60 * 24;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     case 'bytes':
       switch ($src_unit) {
         case 'byte':
         case 'bytes':
           $factor = 1;
           break;
         case 'bit':
         case 'bits':
           $factor = 8;
           $is_divisor = true;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     case 'milliseconds':
       switch ($src_unit) {
         case 'second':
         case 'seconds':
           $factor = 1000;
           break;
         case 'minute':
         case 'minutes':
           $factor = 1000 * 60;
           break;
         case 'hour':
         case 'hours':
           $factor = 1000 * 60 * 60;
           break;
         case 'day':
         case 'days':
           $factor = 1000 * 60 * 60 * 24;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     case 'microseconds':
       switch ($src_unit) {
         case 'second':
         case 'seconds':
           $factor = 1000000;
           break;
         case 'minute':
         case 'minutes':
           $factor = 1000000 * 60;
           break;
         case 'hour':
         case 'hours':
           $factor = 1000000 * 60 * 60;
           break;
         case 'day':
         case 'days':
           $factor = 1000000 * 60 * 60 * 24;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     default:
       throw new InvalidArgumentException(
         pht(
           'This function can not convert into the unit "%s".',
           $dst_unit));
   }
 
   if ($is_divisor) {
     if ($quantity % $factor) {
       throw new InvalidArgumentException(
         pht(
           '"%s" is not an exact quantity.',
           $description));
     }
     return (int)($quantity / $factor);
   } else {
     return $quantity * $factor;
   }
 }
 
 
 /**
  * Compute the number of microseconds that have elapsed since an earlier
  * timestamp (from `microtime(true)`).
  *
  * @param double Microsecond-precision timestamp, from `microtime(true)`.
  * @return int Elapsed microseconds.
  */
 function phutil_microseconds_since($timestamp) {
   if (!is_float($timestamp)) {
     throw new Exception(
       pht(
         'Argument to "phutil_microseconds_since(...)" should be a value '.
         'returned from "microtime(true)".'));
   }
 
   $delta = (microtime(true) - $timestamp);
   $delta = 1000000 * $delta;
   $delta = (int)$delta;
 
   return $delta;
 }
 
 
 /**
  * Decode a JSON dictionary.
  *
  * @param   string    A string which ostensibly contains a JSON-encoded list or
  *                    dictionary.
  * @return  mixed     Decoded list/dictionary.
  */
 function phutil_json_decode($string) {
   $result = @json_decode($string, true);
 
   if (!is_array($result)) {
     // Failed to decode the JSON. Try to use @{class:PhutilJSONParser} instead.
     // This will probably fail, but will throw a useful exception.
     $parser = new PhutilJSONParser();
     $result = $parser->parse($string);
   }
 
   return $result;
 }
 
 
 /**
  * Encode a value in JSON, raising an exception if it can not be encoded.
  *
  * @param wild A value to encode.
  * @return string JSON representation of the value.
  */
 function phutil_json_encode($value) {
   $result = @json_encode($value);
   if ($result === false) {
     $reason = phutil_validate_json($value);
     if (function_exists('json_last_error')) {
       $err = json_last_error();
       if (function_exists('json_last_error_msg')) {
         $msg = json_last_error_msg();
         $extra = pht('#%d: %s', $err, $msg);
       } else {
         $extra = pht('#%d', $err);
       }
     } else {
       $extra = null;
     }
 
     if ($extra) {
       $message = pht(
         'Failed to JSON encode value (%s): %s.',
         $extra,
         $reason);
     } else {
       $message = pht(
         'Failed to JSON encode value: %s.',
         $reason);
     }
 
     throw new Exception($message);
   }
 
   return $result;
 }
 
 
 /**
  * Produce a human-readable explanation why a value can not be JSON-encoded.
  *
  * @param wild Value to validate.
  * @param string Path within the object to provide context.
  * @return string|null Explanation of why it can't be encoded, or null.
  */
 function phutil_validate_json($value, $path = '') {
   if ($value === null) {
     return;
   }
 
   if ($value === true) {
     return;
   }
 
   if ($value === false) {
     return;
   }
 
   if (is_int($value)) {
     return;
   }
 
   if (is_float($value)) {
     return;
   }
 
   if (is_array($value)) {
     foreach ($value as $key => $subvalue) {
       if (strlen($path)) {
         $full_key = $path.' > ';
       } else {
         $full_key = '';
       }
 
       if (!phutil_is_utf8($key)) {
         $full_key = $full_key.phutil_utf8ize($key);
         return pht(
           'Dictionary key "%s" is not valid UTF8, and cannot be JSON encoded.',
           $full_key);
       }
 
       $full_key .= $key;
       $result = phutil_validate_json($subvalue, $full_key);
       if ($result !== null) {
         return $result;
       }
     }
   }
 
   if (is_string($value)) {
     if (!phutil_is_utf8($value)) {
       $display = substr($value, 0, 256);
       $display = phutil_utf8ize($display);
       if (!strlen($path)) {
         return pht(
           'String value is not valid UTF8, and can not be JSON encoded: %s',
           $display);
       } else {
         return pht(
           'Dictionary value at key "%s" is not valid UTF8, and cannot be '.
           'JSON encoded: %s',
           $path,
           $display);
       }
     }
   }
 
   return;
 }
 
 
 /**
  * Decode an INI string.
  *
  * @param  string
  * @return mixed
  */
 function phutil_ini_decode($string) {
   $results = null;
   $trap = new PhutilErrorTrap();
 
   try {
     $have_call = false;
     if (function_exists('parse_ini_string')) {
       if (defined('INI_SCANNER_RAW')) {
         $results = @parse_ini_string($string, true, INI_SCANNER_RAW);
         $have_call = true;
       }
     }
 
     if (!$have_call) {
       throw new PhutilMethodNotImplementedException(
         pht(
           '%s is not compatible with your version of PHP (%s). This function '.
           'is only supported on PHP versions newer than 5.3.0.',
           __FUNCTION__,
           phpversion()));
     }
 
     if ($results === false) {
       throw new PhutilINIParserException(trim($trap->getErrorsAsString()));
     }
 
     foreach ($results as $section => $result) {
       if (!is_array($result)) {
         // We JSON decode the value in ordering to perform the following
         // conversions:
         //
         //   - `'true'` => `true`
         //   - `'false'` => `false`
         //   - `'123'` => `123`
         //   - `'1.234'` => `1.234`
         //
         $result = json_decode($result, true);
 
         if ($result !== null && !is_array($result)) {
           $results[$section] = $result;
         }
 
         continue;
       }
 
       foreach ($result as $key => $value) {
         $value = json_decode($value, true);
 
         if ($value !== null && !is_array($value)) {
           $results[$section][$key] = $value;
         }
       }
     }
   } catch (Exception $ex) {
     $trap->destroy();
     throw $ex;
   }
 
   $trap->destroy();
   return $results;
 }
 
 
 /**
  * Attempt to censor any plaintext credentials from a string.
  *
  * The major use case here is to censor usernames and passwords from command
  * output. For example, when `git fetch` fails, the output includes credentials
  * for authenticated HTTP remotes.
  *
  * @param   string  Some block of text.
  * @return  string  A similar block of text, but with credentials that could
  *                  be identified censored.
  */
 function phutil_censor_credentials($string) {
   return preg_replace(',(?<=://)([^/@\s]+)(?=@|$),', '********', $string);
 }
 
 
 /**
  * Returns a parsable string representation of a variable.
  *
  * This function is intended to behave similarly to PHP's `var_export` function,
  * but the output is intended to follow our style conventions.
  *
  * @param  wild    The variable you want to export.
  * @return string
  */
 function phutil_var_export($var) {
   // `var_export(null, true)` returns `"NULL"` (in uppercase).
   if ($var === null) {
     return 'null';
   }
 
   // PHP's `var_export` doesn't format arrays very nicely. In particular:
   //
   //   - An empty array is split over two lines (`"array (\n)"`).
   //   - A space separates "array" and the first opening brace.
   //   - Non-associative arrays are returned as associative arrays with an
   //     integer key.
   //
   if (is_array($var)) {
     if (count($var) === 0) {
       return 'array()';
     }
 
     // Don't show keys for non-associative arrays.
     $show_keys = !phutil_is_natural_list($var);
 
     $output = array();
     $output[] = 'array(';
 
     foreach ($var as $key => $value) {
       // Adjust the indentation of the value.
       $value = str_replace("\n", "\n  ", phutil_var_export($value));
       $output[] = '  '.
         ($show_keys ? var_export($key, true).' => ' : '').
         $value.',';
     }
 
     $output[] = ')';
     return implode("\n", $output);
   }
 
   // Let PHP handle everything else.
   return var_export($var, true);
 }
 
 
 /**
  * An improved version of `fnmatch`.
  *
  * @param  string  A glob pattern.
  * @param  string  A path.
  * @return bool
  */
 function phutil_fnmatch($glob, $path) {
   // Modify the glob to allow `**/` to match files in the root directory.
   $glob = preg_replace('@(?:(?<!\\\\)\\*){2}/@', '{,*/,**/}', $glob);
 
   $escaping = false;
   $in_curlies = 0;
   $regex = '';
 
   for ($i = 0; $i < strlen($glob); $i++) {
     $char = $glob[$i];
     $next_char = ($i < strlen($glob) - 1) ? $glob[$i + 1] : null;
 
     $escape = array('$', '(', ')', '+', '.', '^', '|');
     $mapping = array();
 
     if ($escaping) {
       $escape[] = '*';
       $escape[] = '?';
       $escape[] = '{';
     } else {
       $mapping['*'] = $next_char === '*' ? '.*' : '[^/]*';
       $mapping['?'] = '[^/]';
       $mapping['{'] = '(';
 
       if ($in_curlies) {
         $mapping[','] = '|';
         $mapping['}'] = ')';
       }
     }
 
     if (in_array($char, $escape)) {
       $regex .= "\\{$char}";
     } else if ($replacement = idx($mapping, $char)) {
       $regex .= $replacement;
     } else if ($char === '\\') {
       if ($escaping) {
         $regex .= '\\\\';
       }
       $escaping = !$escaping;
       continue;
     } else {
       $regex .= $char;
     }
 
     if ($char === '{' && !$escaping) {
       $in_curlies++;
     } else if ($char === '}' && $in_curlies && !$escaping) {
       $in_curlies--;
     }
 
     $escaping = false;
   }
 
   if ($in_curlies || $escaping) {
     throw new InvalidArgumentException(pht('Invalid glob pattern.'));
   }
 
   $regex = '(\A'.$regex.'\z)';
   return (bool)preg_match($regex, $path);
 }
 
 
 /**
  * Compare two hashes for equality.
  *
  * This function defuses two attacks: timing attacks and type juggling attacks.
  *
  * In a timing attack, the attacker observes that strings which match the
  * secret take slightly longer to fail to match because more characters are
  * compared. By testing a large number of strings, they can learn the secret
  * character by character. This defuses timing attacks by always doing the
  * same amount of work.
  *
  * In a type juggling attack, an attacker takes advantage of PHP's type rules
  * where `"0" == "0e12345"` for any exponent. A portion of of hexadecimal
  * hashes match this pattern and are vulnerable. This defuses this attack by
  * performing bytewise character-by-character comparison.
  *
  * It is questionable how practical these attacks are, but they are possible
  * in theory and defusing them is straightforward.
  *
  * @param string First hash.
  * @param string Second hash.
  * @return bool True if hashes are identical.
  */
 function phutil_hashes_are_identical($u, $v) {
   if (!is_string($u)) {
     throw new Exception(pht('First hash argument must be a string.'));
   }
 
   if (!is_string($v)) {
     throw new Exception(pht('Second hash argument must be a string.'));
   }
 
   if (strlen($u) !== strlen($v)) {
     return false;
   }
 
   $len = strlen($v);
 
   $bits = 0;
   for ($ii = 0; $ii < $len; $ii++) {
     $bits |= (ord($u[$ii]) ^ ord($v[$ii]));
   }
 
   return ($bits === 0);
 }
 
 
 /**
  * Build a query string from a dictionary.
  *
  * @param map<string, string> Dictionary of parameters.
  * @return string HTTP query string.
  */
 function phutil_build_http_querystring(array $parameters) {
   $pairs = array();
   foreach ($parameters as $key => $value) {
     $pairs[] = array($key, $value);
   }
 
   return phutil_build_http_querystring_from_pairs($pairs);
 }
 
 /**
  * Build a query string from a list of parameter pairs.
  *
  * @param list<pair<string, string>> List of pairs.
  * @return string HTTP query string.
  */
 function phutil_build_http_querystring_from_pairs(array $pairs) {
   // We want to encode in RFC3986 mode, but "http_build_query()" did not get
   // a flag for that mode until PHP 5.4.0. This is equivalent to calling
   // "http_build_query()" with the "PHP_QUERY_RFC3986" flag.
 
   $query = array();
   foreach ($pairs as $pair_key => $pair) {
     if (!is_array($pair) || (count($pair) !== 2)) {
       throw new Exception(
         pht(
           'HTTP parameter pair (with key "%s") is not valid: each pair must '.
           'be an array with exactly two elements.',
           $pair_key));
     }
 
     list($key, $value) = $pair;
     list($key, $value) = phutil_http_parameter_pair($key, $value);
     $query[] = rawurlencode($key).'='.rawurlencode($value);
   }
   $query = implode('&', $query);
 
   return $query;
 }
 
 /**
  * Typecheck and cast an HTTP key-value parameter pair.
  *
  * Scalar values are converted to strings. Nonscalar values raise exceptions.
  *
  * @param scalar HTTP parameter key.
  * @param scalar HTTP parameter value.
  * @return pair<string, string> Key and value as strings.
  */
 function phutil_http_parameter_pair($key, $value) {
   try {
     assert_stringlike($key);
   } catch (InvalidArgumentException $ex) {
     throw new PhutilProxyException(
       pht('HTTP query parameter key must be a scalar.'),
       $ex);
   }
 
   $key = phutil_string_cast($key);
 
   try {
     assert_stringlike($value);
   } catch (InvalidArgumentException $ex) {
     throw new PhutilProxyException(
       pht(
         'HTTP query parameter value (for key "%s") must be a scalar.',
         $key),
       $ex);
   }
 
   $value = phutil_string_cast($value);
 
   return array($key, $value);
 }
 
 function phutil_decode_mime_header($header) {
   if (function_exists('iconv_mime_decode')) {
     return iconv_mime_decode($header, 0, 'UTF-8');
   }
 
   if (function_exists('mb_decode_mimeheader')) {
     return mb_decode_mimeheader($header);
   }
 
   throw new Exception(
     pht(
       'Unable to decode MIME header: install "iconv" or "mbstring" '.
       'extension.'));
 }
 
 /**
  * Perform a "(string)" cast without disabling standard exception behavior.
  *
  * When PHP invokes "__toString()" automatically, it fatals if the method
  * raises an exception. In older versions of PHP (until PHP 7.1), this fatal is
  * fairly opaque and does not give you any information about the exception
  * itself, although newer versions of PHP at least include the exception
  * message.
  *
  * This is documented on the "__toString()" manual page:
  *
  *   Warning
  *   You cannot throw an exception from within a __toString() method. Doing
  *   so will result in a fatal error.
  *
  * However, this only applies to implicit invocation by the language runtime.
  * Application code can safely call `__toString()` directly without any effect
  * on exception handling behavior. Very cool.
  *
  * We also reject arrays. PHP casts them to the string "Array". This behavior
  * is, charitably, evil.
  *
  * @param wild Any value which aspires to be represented as a string.
  * @return string String representation of the provided value.
  */
 function phutil_string_cast($value) {
   if (is_array($value)) {
     throw new Exception(
       pht(
         'Value passed to "phutil_string_cast()" is an array; arrays can '.
         'not be sensibly cast to strings.'));
   }
 
   if (is_object($value)) {
     $string = $value->__toString();
 
     if (!is_string($string)) {
       throw new Exception(
         pht(
           'Object (of class "%s") did not return a string from "__toString()".',
           get_class($value)));
     }
 
     return $string;
   }
 
   return (string)$value;
 }
 
 
 /**
  * Return a short, human-readable description of an object's type.
  *
  * This is mostly useful for raising errors like "expected x() to return a Y,
  * but it returned a Z".
  *
  * This is similar to "get_type()", but describes objects and arrays in more
  * detail.
  *
  * @param wild Anything.
  * @return string Human-readable description of the value's type.
  */
 function phutil_describe_type($value) {
   return PhutilTypeSpec::getTypeOf($value);
 }
 
 
 /**
  * Test if a list has the natural numbers (1, 2, 3, and so on) as keys, in
  * order.
  *
  * @return bool True if the list is a natural list.
  */
 function phutil_is_natural_list(array $list) {
   $expect = 0;
 
   foreach ($list as $key => $item) {
     if ($key !== $expect) {
       return false;
     }
     $expect++;
   }
 
   return true;
 }
 
 
 /**
  * Escape text for inclusion in a URI or a query parameter. Note that this
  * method does NOT escape '/', because "%2F" is invalid in paths and Apache
  * will automatically 404 the page if it's present. This will produce correct
  * (the URIs will work) and desirable (the URIs will be readable) behavior in
  * these cases:
  *
  *    '/path/?param='.phutil_escape_uri($string);         # OK: Query Parameter
  *    '/path/to/'.phutil_escape_uri($string);             # OK: URI Suffix
  *
  * It will potentially produce the WRONG behavior in this special case:
  *
  *    COUNTEREXAMPLE
  *    '/path/to/'.phutil_escape_uri($string).'/thing/';   # BAD: URI Infix
  *
  * In this case, any '/' characters in the string will not be escaped, so you
  * will not be able to distinguish between the string and the suffix (unless
  * you have more information, like you know the format of the suffix). For infix
  * URI components, use @{function:phutil_escape_uri_path_component} instead.
  *
  * @param   string  Some string.
  * @return  string  URI encoded string, except for '/'.
  */
 function phutil_escape_uri($string) {
   return str_replace('%2F', '/', rawurlencode($string));
 }
 
 
 /**
  * Escape text for inclusion as an infix URI substring. See discussion at
  * @{function:phutil_escape_uri}. This function covers an unusual special case;
  * @{function:phutil_escape_uri} is usually the correct function to use.
  *
  * This function will escape a string into a format which is safe to put into
  * a URI path and which does not contain '/' so it can be correctly parsed when
  * embedded as a URI infix component.
  *
  * However, you MUST decode the string with
  * @{function:phutil_unescape_uri_path_component} before it can be used in the
  * application.
  *
  * @param   string  Some string.
  * @return  string  URI encoded string that is safe for infix composition.
  */
 function phutil_escape_uri_path_component($string) {
   return rawurlencode(rawurlencode($string));
 }
 
 
 /**
  * Unescape text that was escaped by
  * @{function:phutil_escape_uri_path_component}. See
  * @{function:phutil_escape_uri} for discussion.
  *
  * Note that this function is NOT the inverse of
  * @{function:phutil_escape_uri_path_component}! It undoes additional escaping
  * which is added to survive the implied unescaping performed by the webserver
  * when interpreting the request.
  *
  * @param string  Some string emitted
  *                from @{function:phutil_escape_uri_path_component} and
  *                then accessed via a web server.
  * @return string Original string.
  */
 function phutil_unescape_uri_path_component($string) {
   return rawurldecode($string);
 }
 
 function phutil_is_noninteractive() {
   if (function_exists('posix_isatty') && !posix_isatty(STDIN)) {
     return true;
   }
 
   return false;
 }
 
 function phutil_is_interactive() {
   if (function_exists('posix_isatty') && posix_isatty(STDIN)) {
     return true;
   }
 
   return false;
 }
 
 function phutil_encode_log($message) {
   return addcslashes($message, "\0..\37\\\177..\377");
 }
 
 /**
  * Insert a value in between each pair of elements in a list.
  *
  * Keys in the input list are preserved.
  */
 function phutil_glue(array $list, $glue) {
   if (!$list) {
     return $list;
   }
 
   $last_key = last_key($list);
 
   $keys = array();
   $values = array();
 
   $tmp = $list;
 
   foreach ($list as $key => $ignored) {
     $keys[] = $key;
     if ($key !== $last_key) {
       $tmp[] = $glue;
       $keys[] = last_key($tmp);
     }
   }
 
   return array_select_keys($tmp, $keys);
 }
 
 function phutil_partition(array $map) {
   $partitions = array();
 
   $partition = array();
   $is_first = true;
   $partition_value = null;
 
   foreach ($map as $key => $value) {
     if (!$is_first) {
       if ($partition_value === $value) {
         $partition[$key] = $value;
         continue;
       }
 
       $partitions[] = $partition;
     }
 
     $is_first = false;
     $partition = array($key => $value);
     $partition_value = $value;
   }
 
   if ($partition) {
     $partitions[] = $partition;
   }
 
   return $partitions;
 }
 
 function phutil_preg_match(
   $pattern,
   $subject,
   $flags = 0,
   $offset = 0) {
 
   $matches = null;
   $result = @preg_match($pattern, $subject, $matches, $flags, $offset);
   if ($result === false || $result === null) {
     phutil_raise_preg_exception(
       'preg_match',
       array(
         $pattern,
         $subject,
         $matches,
         $flags,
         $offset,
       ));
   }
 
   return $matches;
 }
 
 function phutil_preg_match_all(
   $pattern,
   $subject,
   $flags = 0,
   $offset = 0) {
 
   $matches = null;
   $result = @preg_match_all($pattern, $subject, $matches, $flags, $offset);
   if ($result === false || $result === null) {
     phutil_raise_preg_exception(
       'preg_match_all',
       array(
         $pattern,
         $subject,
         $matches,
         $flags,
         $offset,
       ));
   }
 
   return $matches;
 }
 
 function phutil_raise_preg_exception($function, array $argv) {
   $trap = new PhutilErrorTrap();
 
   // NOTE: This ugly construction to avoid issues with reference behavior when
   // passing values through "call_user_func_array()".
 
   switch ($function) {
     case 'preg_match':
       @preg_match($argv[0], $argv[1], $argv[2], $argv[3], $argv[4]);
       break;
     case 'preg_match_all':
       @preg_match_all($argv[0], $argv[1], $argv[2], $argv[3], $argv[4]);
       break;
   }
   $error_message = $trap->getErrorsAsString();
 
   $trap->destroy();
 
   $pattern = $argv[0];
   $pattern_display = sprintf(
     '"%s"',
     addcslashes($pattern, '\\\"'));
 
   $message = array();
   $message[] = pht(
     'Call to %s(%s, ...) failed.',
     $function,
     $pattern_display);
 
   if (strlen($error_message)) {
     $message[] = pht(
       'Regular expression engine emitted message: %s',
       $error_message);
   }
 
   $message = implode("\n\n", $message);
 
   throw new PhutilRegexException($message);
 }
+
+
+/**
+ * Test if a value is a nonempty string.
+ *
+ * The value "null" and the empty string are considered empty; all other
+ * strings are considered nonempty.
+ *
+ * This method raises an exception if passed a value which is neither null
+ * nor a string.
+ *
+ * @param Value to test.
+ * @return bool True if the parameter is a nonempty string.
+ */
+function phutil_nonempty_string($value) {
+  if ($value === null) {
+    return false;
+  }
+
+  if ($value === '') {
+    return false;
+  }
+
+  if (is_string($value)) {
+    return true;
+  }
+
+  throw new InvalidArgumentException(
+    pht(
+      'Call to phutil_nonempty_string() expected null or a string, got: %s.',
+      phutil_describe_type($value)));
+}
+
+
+/**
+ * Test if a value is a nonempty, stringlike value.
+ *
+ * The value "null", the empty string, and objects which have a "__toString()"
+ * method which returns the empty string are empty.
+ *
+ * Other strings, and objects with a "__toString()" method that returns a
+ * string other than the empty string are considered nonempty.
+ *
+ * This method raises an exception if passed any other value.
+ *
+ * @param Value to test.
+ * @return bool True if the parameter is a nonempty, stringlike value.
+ */
+function phutil_nonempty_stringlike($value) {
+  if ($value === null) {
+    return false;
+  }
+
+  if ($value === '') {
+    return false;
+  }
+
+  if (is_string($value)) {
+    return true;
+  }
+
+  if (is_object($value)) {
+    try {
+      $string = phutil_string_cast($value);
+      return phutil_nonempty_string($string);
+    } catch (Exception $ex) {
+      // Continue below.
+    } catch (Throwable $ex) {
+      // Continue below.
+    }
+  }
+
+  throw new InvalidArgumentException(
+    pht(
+      'Call to phutil_nonempty_stringlike() expected a string or stringlike '.
+      'object, got: %s.',
+      phutil_describe_type($value)));
+}
+
+
+/**
+ * Test if a value is a nonempty, scalar value.
+ *
+ * The value "null", the empty string, and objects which have a "__toString()"
+ * method which returns the empty string are empty.
+ *
+ * Other strings, objects with a "__toString()" method which returns a
+ * string other than the empty string, integers, and floats are considered
+ * scalar.
+ *
+ * This method raises an exception if passed any other value.
+ *
+ * @param Value to test.
+ * @return bool True if the parameter is a nonempty, scalar value.
+ */
+function phutil_nonempty_scalar($value) {
+  if ($value === null) {
+    return false;
+  }
+
+  if ($value === '') {
+    return false;
+  }
+
+  if (is_string($value) || is_int($value) || is_float($value)) {
+    return true;
+  }
+
+  if (is_object($value)) {
+    try {
+      $string = phutil_string_cast($value);
+      return phutil_nonempty_string($string);
+    } catch (Exception $ex) {
+      // Continue below.
+    } catch (Throwable $ex) {
+      // Continue below.
+    }
+  }
+
+  throw new InvalidArgumentException(
+    pht(
+      'Call to phutil_nonempty_scalar() expected: a string; or stringlike '.
+      'object; or int; or float. Got: %s.',
+      phutil_describe_type($value)));
+}
diff --git a/src/utils/viewutils.php b/src/utils/viewutils.php
index ea7f74ed..b660de42 100644
--- a/src/utils/viewutils.php
+++ b/src/utils/viewutils.php
@@ -1,170 +1,170 @@
 <?php
 
 function phutil_date_format($epoch) {
   $now = time();
   $shift = 30 * 24 * 60 * 60;
   if ($epoch < $now + $shift && $epoch > $now - $shift) {
     $format = pht('D, M j');
   } else {
     $format = pht('M j Y');
   }
   return $format;
 }
 
 function phutil_format_relative_time($duration) {
   return phutil_format_units_generic(
     $duration,
     array(60, 60, 24, 7),
     array('s', 'm', 'h', 'd', 'w'),
     $precision = 0);
 }
 
 /**
  * Format a relative time (duration) into weeks, days, hours, minutes,
  * seconds, but unlike phabricator_format_relative_time, does so for more than
  * just the largest unit.
  *
  * @param int Duration in seconds.
  * @param int Levels to render - will render the three highest levels, ie:
  *            5 h, 37 m, 1 s
  * @return string Human-readable description.
  */
 function phutil_format_relative_time_detailed($duration, $levels = 2) {
   if ($duration == 0) {
     return 'now';
   }
   $levels = max(1, min($levels, 5));
   $remainder = 0;
 
   $is_negative = false;
   if ($duration < 0) {
     $is_negative = true;
     $duration = abs($duration);
   }
 
   $this_level = 1;
   $detailed_relative_time = phutil_format_units_generic(
     $duration,
     array(60, 60, 24, 7),
     array('s', 'm', 'h', 'd', 'w'),
     $precision = 0,
     $remainder);
   $duration = $remainder;
 
   while ($remainder > 0 && $this_level < $levels) {
     $detailed_relative_time .= ', '.phutil_format_units_generic(
       $duration,
       array(60, 60, 24, 7),
       array('s', 'm', 'h', 'd', 'w'),
       $precision = 0,
       $remainder);
     $duration = $remainder;
     $this_level++;
   }
 
   if ($is_negative) {
     $detailed_relative_time .= ' ago';
   }
 
   return $detailed_relative_time;
 }
 
 /**
  * Format a byte count for human consumption, e.g. "10MB" instead of
  * "10485760".
  *
  * @param int Number of bytes.
  * @return string Human-readable description.
  */
 function phutil_format_bytes($bytes) {
   return phutil_format_units_generic(
     $bytes,
     array(1024, 1024, 1024, 1024, 1024),
     array('B', 'KB', 'MB', 'GB', 'TB', 'PB'),
     $precision = 0);
 }
 
 
 /**
  * Parse a human-readable byte description (like "6MB") into an integer.
  *
  * @param string  Human-readable description.
  * @return int    Number of represented bytes.
  */
 function phutil_parse_bytes($input) {
   $bytes = trim($input);
   if (!strlen($bytes)) {
     return null;
   }
 
   // NOTE: Assumes US-centric numeral notation.
   $bytes = preg_replace('/[ ,]/', '', $bytes);
 
   $matches = null;
   if (!preg_match('/^(?:\d+(?:[.]\d+)?)([kmgtp]?)b?$/i', $bytes, $matches)) {
     throw new Exception(pht("Unable to parse byte size '%s'!", $input));
   }
 
   $scale = array(
     'k' => 1024,
     'm' => 1024 * 1024,
     'g' => 1024 * 1024 * 1024,
     't' => 1024 * 1024 * 1024 * 1024,
     'p' => 1024 * 1024 * 1024 * 1024 * 1024,
   );
 
   $bytes = (float)$bytes;
   if ($matches[1]) {
     $bytes *= $scale[strtolower($matches[1])];
   }
 
   return (int)$bytes;
 }
 
 
 function phutil_format_units_generic(
   $n,
   array $scales,
   array $labels,
   $precision  = 0,
   &$remainder = null) {
 
   $is_negative = false;
   if ($n < 0) {
     $is_negative = true;
     $n = abs($n);
   }
 
   $remainder = 0;
   $accum = 1;
 
   $scale = array_shift($scales);
   $label = array_shift($labels);
   while ($n >= $scale && count($labels)) {
-    $remainder += ($n % $scale) * $accum;
+    $remainder += ((int)$n % $scale) * $accum;
     $n /= $scale;
     $accum *= $scale;
     $label = array_shift($labels);
     if (!count($scales)) {
       break;
     }
     $scale = array_shift($scales);
   }
 
   if ($is_negative) {
     $n = -$n;
     $remainder = -$remainder;
   }
 
   if ($precision) {
     $num_string = number_format($n, $precision);
   } else {
     $num_string = (int)floor($n);
   }
 
   if ($label) {
     $num_string .= ' '.$label;
   }
 
   return $num_string;
 }
diff --git a/src/workflow/ArcanistCallConduitWorkflow.php b/src/workflow/ArcanistCallConduitWorkflow.php
index 025be3e1..5402ee16 100644
--- a/src/workflow/ArcanistCallConduitWorkflow.php
+++ b/src/workflow/ArcanistCallConduitWorkflow.php
@@ -1,78 +1,77 @@
 <?php
 
 final class ArcanistCallConduitWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'call-conduit';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 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:
+This workflow is primarily useful for writing scripts. Examples:
 
   $ echo '{}' | arc call-conduit -- conduit.ping
   $ echo '{"phid":"PHID-FILE-xxxx"}' | arc call-conduit -- file.download
 EOTEXT
       );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Call Conduit API methods.'))
       ->addExample('**call-conduit** -- __method__')
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('method')
         ->setWildcard(true),
     );
   }
 
   public function runWorkflow() {
     $method = $this->getArgument('method');
     if (count($method) !== 1) {
       throw new PhutilArgumentUsageException(
         pht('Provide exactly one Conduit method name to call.'));
     }
     $method = head($method);
 
     $params = $this->readStdin();
     try {
       $params = phutil_json_decode($params);
     } catch (PhutilJSONParserException $ex) {
       throw new ArcanistUsageException(
         pht('Provide method parameters on stdin as a JSON blob.'));
     }
 
     $engine = $this->getConduitEngine();
     $conduit_future = $engine->newFuture($method, $params);
 
     $error = null;
     $error_message = null;
     try {
       $result = $conduit_future->resolve();
     } catch (ConduitClientException $ex) {
       $error = $ex->getErrorCode();
       $error_message = $ex->getMessage();
       $result = null;
     }
 
     echo id(new PhutilJSON())->encodeFormatted(
       array(
         'error' => $error,
         'errorMessage' => $error_message,
         'response' => $result,
       ));
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistDiffWorkflow.php b/src/workflow/ArcanistDiffWorkflow.php
index 7201a003..5b8ff40c 100644
--- a/src/workflow/ArcanistDiffWorkflow.php
+++ b/src/workflow/ArcanistDiffWorkflow.php
@@ -1,2899 +1,2900 @@
 <?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
  */
 final class ArcanistDiffWorkflow extends ArcanistWorkflow {
 
   private $console;
   private $hasWarnedExternals = false;
   private $unresolvedLint;
   private $testResults;
   private $diffID;
   private $revisionID;
   private $diffPropertyFutures = array();
   private $commitMessageFromRevision;
   private $hitAutotargets;
   private $revisionTransactions;
   private $revisionIsDraft;
 
   const STAGING_PUSHED = 'pushed';
   const STAGING_USER_SKIP = 'user.skip';
   const STAGING_DIFF_RAW = 'diff.raw';
   const STAGING_REPOSITORY_UNKNOWN = 'repository.unknown';
   const STAGING_REPOSITORY_UNAVAILABLE = 'repository.unavailable';
   const STAGING_REPOSITORY_UNSUPPORTED = 'repository.unsupported';
   const STAGING_REPOSITORY_UNCONFIGURED = 'repository.unconfigured';
   const STAGING_CLIENT_UNSUPPORTED = 'client.unsupported';
 
   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;
     }
 
     return false;
   }
 
   public function getDiffID() {
     return $this->diffID;
   }
 
   public function getArguments() {
     $arguments = array(
       'message' => array(
         'short'       => 'm',
         'param'       => 'message',
         'help' => pht(
           'When updating a revision, use the specified message instead of '.
           'prompting.'),
       ),
       'message-file' => array(
         'short' => 'F',
         'param' => 'file',
         'paramtype' => 'file',
         'help' => pht(
           'When creating a revision, read revision information '.
           'from this file.'),
       ),
       'edit' => array(
         'supports'    => array(
           'git',
           'hg',
         ),
         'nosupport'   => array(
           'svn' => pht('Edit revisions via the web interface when using SVN.'),
         ),
         'help' => pht(
           'When updating a revision under git, edit revision information '.
           'before updating.'),
       ),
       'raw' => array(
         'help' => pht(
           'Read diff from stdin, not from the working copy. This disables '.
-          'many Arcanist/Phabricator features which depend on having access '.
-          'to the working copy.'),
+          'many features which depend on having access to the working copy.'),
         'conflicts' => array(
           'apply-patches'       => pht('%s disables lint.', '--raw'),
           'never-apply-patches' => pht('%s disables lint.', '--raw'),
 
           'create'              => pht(
             '%s and %s both need stdin. Use %s.',
             '--raw',
             '--create',
             '--raw-command'),
           'edit'                => pht(
             '%s and %s both need stdin. Use %s.',
             '--raw',
             '--edit',
             '--raw-command'),
           'raw-command'         => null,
         ),
       ),
       'raw-command' => array(
         'param' => 'command',
         'help' => pht(
           '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.'),
+          'working copy. This disables many features which depend on having '.
+          'access to the working copy.'),
         'conflicts' => array(
           'apply-patches'       => pht('%s disables lint.', '--raw-command'),
           'never-apply-patches' => pht('%s disables lint.', '--raw-command'),
         ),
       ),
       'create' => array(
         'help' => pht('Always create a new revision.'),
         'conflicts' => array(
           'edit'    => pht(
             '%s can not be used with %s.',
             '--create',
             '--edit'),
           'only' => pht(
             '%s can not be used with %s.',
             '--create',
             '--only'),
           'update'  => pht(
             '%s can not be used with %s.',
             '--create',
             '--update'),
         ),
       ),
       'update' => array(
         'param' => 'revision_id',
         'help'  => pht('Always update a specific revision.'),
       ),
       'draft' => array(
         'help' => pht(
           'Create a draft revision so you can look over your changes before '.
           'involving anyone else. Other users will not be notified about the '.
           'revision until you later use "Request Review" to publish it. You '.
           'can still share the draft by giving someone the link.'),
         'conflicts' => array(
           'edit' => null,
           'only' => null,
           'update' => null,
         ),
       ),
       'nounit' => array(
         'help' => pht('Do not run unit tests.'),
       ),
       'nolint' => array(
         'help' => pht('Do not run lint.'),
         'conflicts' => array(
           'apply-patches' => pht('%s suppresses lint.', '--nolint'),
           'never-apply-patches' => pht('%s suppresses lint.', '--nolint'),
         ),
       ),
       'only' => array(
         'help' => pht(
           'Instead of creating or updating a revision, only create a diff, '.
           'which you may later attach to a revision.'),
         'conflicts' => array(
           'edit'      => pht('%s does affect revisions.', '--only'),
           'message'   => pht('%s does not update any revision.', '--only'),
         ),
       ),
       'allow-untracked' => array(
         'help' => pht('Skip checks for untracked files in the working copy.'),
       ),
       'apply-patches' => array(
         'help' => pht(
           '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' => pht('Never apply patches suggested by lint.'),
         'conflicts' => array(
           'apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-all' => array(
         'help' => pht(
           'When linting git repositories, amend HEAD with all patches '.
           'suggested by lint without prompting.'),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-autofixes' => array(
         'help' => pht(
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.'),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'add-all' => array(
         'short' => 'a',
         'help' => pht(
           'Automatically add all unstaged and uncommitted '.
           'files to the commit.'),
       ),
       'json' => array(
         'help' => pht(
           'Emit machine-readable JSON. EXPERIMENTAL! Probably does not work!'),
       ),
       'no-amend' => array(
         'help' => pht(
           'Never amend commits in the working copy with lint patches.'),
       ),
       'uncommitted' => array(
         'help' => pht('Suppress warning about uncommitted changes.'),
         'supports' => array(
           'hg',
         ),
       ),
       'verbatim' => array(
         'help' => pht(
           '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(
           'update'              => true,
           'only' => true,
           'raw'                 => true,
           'raw-command'         => true,
           'message-file'        => true,
         ),
       ),
       'reviewers' => array(
         'param' => 'usernames',
         'help' => pht('When creating a revision, add reviewers.'),
         'conflicts' => array(
           'only' => true,
           'update'  => true,
         ),
       ),
       'cc' => array(
         'param' => 'usernames',
         'help' => pht('When creating a revision, add CCs.'),
         'conflicts' => array(
           'only' => true,
           'update'  => true,
         ),
       ),
       'skip-binaries' => array(
         'help'  => pht('Do not upload binaries (like images).'),
       ),
       'skip-staging' => array(
         'help' => pht('Do not copy changes to the staging area.'),
       ),
       'base' => array(
         'param' => 'rules',
         'help'  => pht('Additional rules for determining base revision.'),
         'nosupport' => array(
           'svn' => pht('Subversion does not use base commits.'),
         ),
         'supports' => array('git', 'hg'),
       ),
       'coverage' => array(
         'help' => pht('Always enable coverage information.'),
         'conflicts' => array(
           'no-coverage' => null,
         ),
         'passthru' => array(
           'unit' => true,
         ),
       ),
       'no-coverage' => array(
         'help' => pht('Always disable coverage information.'),
         'passthru' => array(
           'unit' => true,
         ),
       ),
       'browse' => array(
         'help' => pht(
           'After creating a diff or revision, open it in a web browser.'),
       ),
       '*' => '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.'),
+          'Specify the end of the commit range. This disables many 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 %s yet.', '--head'),
         ),
       ),
     );
 
     return $arguments;
   }
 
   public function isRawDiffSource() {
     return $this->getArgument('raw') || $this->getArgument('raw-command');
   }
 
   public function run() {
     $this->console = PhutilConsole::getConsole();
 
     $this->runRepositoryAPISetup();
     $this->runDiffSetupBasics();
 
     $commit_message = $this->buildCommitMessage();
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDBUILDMESSAGE,
       array(
         'message' => $commit_message,
       ));
 
     if (!$this->shouldOnlyCreateDiff()) {
       $revision = $this->buildRevisionFromCommitMessage($commit_message);
     }
 
     $data = $this->runLintUnit();
 
     $lint_result = $data['lintResult'];
     $this->unresolvedLint = $data['unresolvedLint'];
     $unit_result = $data['unitResult'];
     $this->testResults = $data['testResults'];
 
     $changes = $this->generateChanges();
     if (!$changes) {
       throw new ArcanistUsageException(
         pht('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->submitChangesToStagingArea($this->diffID);
 
     $phid = idx($diff_info, 'phid');
     if ($phid) {
       $this->hitAutotargets = $this->updateAutotargets(
         $phid,
         $unit_result);
     }
 
     $this->updateLintDiffProperty();
     $this->updateUnitDiffProperty();
     $this->updateLocalDiffProperty();
     $this->updateOntoDiffProperty();
     $this->resolveDiffPropertyUpdates();
 
     $output_json = $this->getArgument('json');
 
     if ($this->shouldOnlyCreateDiff()) {
       if (!$output_json) {
         echo phutil_console_format(
           "%s\n        **%s** __%s__\n\n",
           pht('Created a new Differential diff:'),
           pht('Diff URI:'),
           $diff_info['uri']);
       } else {
         $human = ob_get_clean();
         echo json_encode(array(
           'diffURI' => $diff_info['uri'],
           'diffID'  => $this->getDiffID(),
           'human'   => $human,
         ))."\n";
         ob_start();
       }
 
       if ($this->shouldOpenCreatedObjectsInBrowser()) {
         $this->openURIsInBrowser(array($diff_info['uri']));
       }
     } else {
       $is_draft = $this->getArgument('draft');
       $revision['diffid'] = $this->getDiffID();
 
       if ($commit_message->getRevisionID()) {
         if ($is_draft) {
           // TODO: In at least some cases, we could raise this earlier in the
           // workflow to save users some time before the workflow aborts.
           if ($this->revisionIsDraft) {
             $this->writeWarn(
               pht('ALREADY A DRAFT'),
               pht(
                 'You are updating a revision ("%s") with the "--draft" flag, '.
                 'but this revision is already a draft. You only need to '.
                 'provide the "--draft" flag when creating a revision. Draft '.
                 'revisions are not published until you explicitly request '.
                 'review from the web UI.',
                 $commit_message->getRevisionMonogram()));
           } else {
             throw new ArcanistUsageException(
               pht(
                 'You are updating a revision ("%s") with the "--draft" flag, '.
                 'but this revision has already been published for review. '.
                 'You can not turn a revision back into a draft once it has '.
                 'been published.',
                 $commit_message->getRevisionMonogram()));
           }
         }
 
         $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);
         }
 
         $result_uri = $result['uri'];
         $result_id = $result['revisionid'];
 
         echo pht('Updated an existing Differential revision:')."\n";
       } else {
         // NOTE: We're either using "differential.revision.edit" (preferred)
         // if we can, or falling back to "differential.createrevision"
         // (the older way) if not.
 
         $xactions = $this->revisionTransactions;
         if ($xactions) {
           $xactions[] = array(
             'type' => 'update',
             'value' => $diff_info['phid'],
           );
 
           if ($is_draft) {
             $xactions[] = array(
               'type' => 'draft',
               'value' => true,
             );
           }
 
           $result = $conduit->callMethodSynchronous(
             'differential.revision.edit',
             array(
               'transactions' => $xactions,
             ));
 
           $result_id = idxv($result, array('object', 'id'));
           if (!$result_id) {
             throw new Exception(
               pht(
                 'Expected a revision ID to be returned by '.
                 '"differential.revision.edit".'));
           }
 
           // TODO: This is hacky, but we don't currently receive a URI back
           // from "differential.revision.edit".
           $result_uri = id(new PhutilURI($this->getConduitURI()))
             ->setPath('/D'.$result_id);
         } else {
           if ($is_draft) {
             throw new ArcanistUsageException(
               pht(
-                'You have specified "--draft", but the version of Phabricator '.
+                'You have specified "--draft", but the software version '.
                 'on the server is too old to support draft revisions. Omit '.
                 'the flag or upgrade the server software.'));
           }
 
           $revision = $this->dispatchWillCreateRevisionEvent($revision);
 
           $result = $conduit->callMethodSynchronous(
             'differential.createrevision',
             $revision);
 
           $result_uri = $result['uri'];
           $result_id = $result['revisionid'];
         }
 
         $revised_message = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => $result_id,
           ));
 
         if ($this->shouldAmend()) {
           $repository_api = $this->getRepositoryAPI();
           if ($repository_api->supportsAmend()) {
             echo pht('Updating commit message...')."\n";
             $repository_api->amendCommit($revised_message);
           } else {
             echo pht(
               'Commit message was not amended. Amending commit message is '.
               'only supported in git and hg (version 2.2 or newer)');
           }
         }
 
         echo pht('Created a new Differential revision:')."\n";
       }
 
       $uri = $result_uri;
       echo phutil_console_format(
         "        **%s** __%s__\n\n",
         pht('Revision URI:'),
         $uri);
 
       if ($this->shouldOpenCreatedObjectsInBrowser()) {
         $this->openURIsInBrowser(array($uri));
       }
     }
 
     echo pht('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();
 
     $repository_api->setBaseCommitArgumentRules(
       $this->getArgument('base', ''));
 
     if ($repository_api->supportsCommitRanges()) {
       $this->parseBaseCommitArgument($this->getArgument('paths'));
     }
 
     $head_commit = $this->getArgument('head');
     if ($head_commit !== null) {
       $repository_api->setHeadCommit($head_commit);
     }
 
   }
 
   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();
       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();
       }
     }
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDCOLLECTCHANGES,
       array());
   }
 
   private function buildRevisionFromCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
 
     $conduit = $this->getConduit();
 
     $revision_id = $message->getRevisionID();
     $revision = array(
       'fields' => $message->getFields(),
     );
     $xactions = $message->getTransactions();
 
     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')
           ->setTaskMessage(pht(
             'Update the details for a revision, then save and exit.'))
           ->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();
       $xactions = $new_message->getTransactions();
 
       $revision['id'] = $revision_id;
       $this->revisionID = $revision_id;
 
       $revision['message'] = $this->getArgument('message');
       if ($revision['message'] === null) {
         $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);
       }
     }
 
     $this->revisionTransactions = $xactions;
 
     return $revision;
   }
 
   protected function shouldOnlyCreateDiff() {
     if ($this->getArgument('create')) {
       return false;
     }
 
     if ($this->getArgument('update')) {
       return false;
     }
 
     if ($this->isRawDiffSource()) {
       return true;
     }
 
     return $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(
           "%s\n\n%s\n\n",
           pht(
             "The working copy includes changes to '%s' paths. These ".
             "changes will not be included in the diff because SVN can not ".
             "commit 'svn:externals' changes alongside normal changes.",
             'svn:externals'),
           pht(
             "Modified '%s' files:",
             'svn:externals'),
           phutil_console_wrap(implode("\n", $warn_externals), 8));
         $prompt = pht('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, pht('Reading diff from stdin...')."\n");
+        PhutilSystem::writeStderr(
+          tsprintf(
+            "%s\n",
+            pht('Reading diff from stdin...')));
         $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(pht('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[] = '    '.pht('Revision %s, %s', $baserev, $path);
         }
         $revlist = implode("\n", $revlist);
 
         foreach ($bases as $path => $baserev) {
           if ($baserev !== $rev) {
             throw new ArcanistUsageException(
               pht(
                 "Base revisions of changed paths are mismatched. Update all ".
                 "paths to the same base revision before creating a diff: ".
                 "\n\n%s",
                 $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(
           pht('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(
           pht('No changes found. (Did you specify the wrong commit range?)'));
       }
       $changes = $parser->parseDiff($diff);
     } else {
       throw new Exception(pht('Repository API is not supported.'));
     }
 
     $limit = 1024 * 1024 * 4;
     foreach ($changes as $change) {
       $size = 0;
       foreach ($change->getHunks() as $hunk) {
         $size += strlen($hunk->getCorpus());
       }
       if ($size > $limit) {
         $byte_warning = pht(
           "Diff for '%s' with context is %s bytes in length. ".
           "Generally, source changes should not be this large.",
           $change->getCurrentPath(),
           new PhutilNumber($size));
         if ($repository_api instanceof ArcanistSubversionAPI) {
           throw new ArcanistUsageException(
             $byte_warning.' '.
             pht(
               "If the file is not a text file, mark it as binary with:".
               "\n\n  $ %s\n",
               'svn propset svn:mime-type application/octet-stream <filename>'));
         } else {
           $confirm = $byte_warning.' '.pht(
             "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(
               pht('Aborted generation of gigantic diff.'));
           }
         }
       }
     }
 
     $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) {
 
             try {
               $try_encoding = $this->getRepositoryEncoding();
             } catch (ConduitClientException $e) {
               if ($e->getErrorCode() == 'ERR-BAD-ARCANIST-PROJECT') {
                 echo phutil_console_wrap(
-                  pht('Lookup of encoding in arcanist project failed: %s',
+                  pht('Lookup of encoding in project failed: %s',
                       $e->getMessage())."\n");
               } 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(
                   pht(
                     "Converted a '%s' hunk from '%s' to UTF-8.\n",
                     $name,
                     $try_encoding));
                 $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 =
         sprintf(
           "%s\n\n%s\n\n    %s\n",
           pht(
             'This diff includes %s 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.',
             phutil_count($utf8_problems)),
           pht(
-            "You can learn more about how Phabricator handles character ".
+            "You can learn more about how this software 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."),
+            "Character Encoding' in the documentation."),
           pht(
             '%s AFFECTED FILE(S)',
             phutil_count($utf8_problems)));
       $confirm = pht(
         'Do you want to mark these %s file(s) as binary and continue?',
         phutil_count($utf8_problems));
 
       echo phutil_console_format(
         "**%s**\n",
         pht('Invalid Content Encoding (Non-UTF8)'));
       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(pht('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);
     }
 
     $futures = id(new FutureIterator($futures))
       ->limit(8);
     foreach ($futures 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->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,
       'unitResult' => $unit_result,
       'testResults' => $this->testResults,
     );
   }
 
 
   /**
    * @task lintunit
    */
   private function runLint() {
     if ($this->getArgument('nolint') ||
         $this->isRawDiffSource() ||
         $this->getArgument('head')) {
       return ArcanistLintWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("%s\n", pht('Linting...'));
     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:
           $this->console->writeOut(
             "<bg:green>** %s **</bg> %s\n",
             pht('LINT OKAY'),
             pht('No lint problems.'));
           break;
         case ArcanistLintWorkflow::RESULT_WARNINGS:
           $this->console->writeOut(
             "<bg:yellow>** %s **</bg> %s\n",
             pht('LINT MESSAGES'),
             pht('Lint issued unresolved warnings.'));
           break;
         case ArcanistLintWorkflow::RESULT_ERRORS:
           $this->console->writeOut(
             "<bg:red>** %s **</bg> %s\n",
             pht('LINT ERRORS'),
             pht('Lint raised errors!'));
           break;
       }
 
       $this->unresolvedLint = array();
       foreach ($lint_workflow->getUnresolvedMessages() as $message) {
         $this->unresolvedLint[] = $message->toDictionary();
       }
 
       return $lint_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut(
         "%s\n",
         pht('No lint engine configured for this project.'));
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut("%s\n", $ex->getMessage());
     }
 
     return null;
   }
 
 
   /**
    * @task lintunit
    */
   private function runUnit() {
     if ($this->getArgument('nounit') ||
         $this->isRawDiffSource() ||
         $this->getArgument('head')) {
       return ArcanistUnitWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("%s\n", pht('Running unit tests...'));
     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>** %s **</bg> %s\n",
             pht('UNIT OKAY'),
             pht('No unit test failures.'));
           break;
         case ArcanistUnitWorkflow::RESULT_UNSOUND:
           $continue = phutil_console_confirm(
             pht(
               'Unit test results included failures, but all failing tests '.
               'are known to be unsound. Ignore unsound test failures?'));
           if (!$continue) {
             throw new ArcanistUserAbortException();
           }
 
           echo phutil_console_format(
             "<bg:yellow>** %s **</bg> %s\n",
             pht('UNIT UNSOUND'),
             pht(
               'Unit testing raised errors, but all '.
               'failing tests are unsound.'));
           break;
         case ArcanistUnitWorkflow::RESULT_FAIL:
           $this->console->writeOut(
             "<bg:red>** %s **</bg> %s\n",
             pht('UNIT ERRORS'),
             pht('Unit testing raised errors!'));
           break;
       }
 
       $this->testResults = array();
       foreach ($unit_workflow->getTestResults() as $test) {
         $this->testResults[] = $test->toDictionary();
       }
 
       return $unit_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut(
         "%s\n",
         pht('No unit test engine is configured for this project.'));
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut("%s\n", $ex->getMessage());
     }
 
     return null;
   }
 
   public function getTestResults() {
     return $this->testResults;
   }
 
 
 /* -(  Commit and Update Messages  )----------------------------------------- */
 
 
   /**
    * @task message
    */
   private function buildCommitMessage() {
     if ($this->getArgument('only')) {
       return null;
     }
 
     $is_create = $this->getArgument('create');
     $is_update = $this->getArgument('update');
     $is_raw = $this->isRawDiffSource();
     $is_verbatim = $this->getArgument('verbatim');
 
     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(
           pht(
             "There are several revisions which match the working copy:\n\n%s\n".
             "Use '%s' to choose one, or '%s' to create a new revision.",
             $this->renderRevisionList($revisions),
             '--update',
             '--create'));
       }
     }
 
     $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(
           pht(
             'Parameter to %s must be a Differential Revision number.',
             '--update'));
       }
       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 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 = id(new PhutilUTF8StringTruncator())
           ->setMaximumGlyphs(64)
           ->truncateString($preview);
 
         if ($preview) {
           $preview = pht('Message begins:')."\n\n       {$preview}\n\n";
         } else {
           $preview = null;
         }
 
         echo pht(
           "You have a saved revision message in '%s'.\n%s".
           "You can use this message, or discard it.",
           $where,
           $preview);
 
         $use = phutil_console_confirm(
           pht('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;
       }
 
       if (!$this->isRawDiffSource()) {
         $message = pht(
           'Included commits in branch %s:',
           $this->getRepositoryAPI()->getBranchName());
       } else {
         $message = pht('Included commits:');
       }
       $included = array_merge(
         array(
           '',
           $message,
           '',
         ),
         $included);
     }
 
     $issues = array_merge(
       array(
         pht('NEW DIFFERENTIAL REVISION'),
         pht('Describe the changes in this new revision.'),
       ),
       $included,
       array(
         '',
         pht(
           'arc could not identify any existing revision in your working copy.'),
         pht('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 .= rtrim('# '.$issue)."\n";
       }
       $template .= "\n";
 
       if ($first && $this->getArgument('verbatim') && !$template_is_default) {
         $new_template = $template;
       } else {
         $new_template = $this->newInteractiveEditor($template)
           ->setName('new-commit')
           ->setTaskMessage(pht(
             'Provide the details for a new revision, then save and exit.'))
           ->editInteractively();
       }
       $first = false;
 
       if ($template_is_default && ($new_template == $template)) {
         throw new ArcanistUsageException(pht('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 = pht('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 pht('Commit message has errors:')."\n\n";
         $issues = array(pht('Resolve these errors:'));
         foreach ($ex->getParserErrors() as $error) {
           echo phutil_console_wrap("- ".$error."\n", 6);
           $issues[] = '  - '.$error;
         }
         echo "\n";
         echo pht('You must resolve these errors to continue.');
         $again = phutil_console_confirm(
           pht('Do you want to edit the message?'),
           $default_no = false);
         if ($again) {
           // Keep going.
         } else {
           $saved = null;
           if ($wrote) {
             $saved = pht('A copy was saved to %s.', $where);
           }
           throw new ArcanistUsageException(
             pht('Message has unresolved errors.')." {$saved}");
         }
       } catch (Exception $ex) {
         if ($wrote) {
           echo phutil_console_wrap(pht('(Message saved to %s.)', $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(
         pht(
           "Revision '%s' does not exist!",
           $revision_id));
     }
 
     $this->checkRevisionOwnership($revision);
 
     // TODO: Save this status to improve a prompt later. See PHI458. This is
     // extra awful until we move to "differential.revision.search" because
     // the "differential.query" method doesn't return a real draft status for
     // compatibility.
     $this->revisionIsDraft = (idx($revision, 'statusName') === 'Draft');
 
     $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) {
       $futures['reviewers'] = $this->getConduit()->callMethod(
         'user.query',
         array(
           'phids' => $reviewers,
         ));
     }
 
     foreach (new FutureIterator($futures) as $key => $future) {
       $result = $future->resolve();
       switch ($key) {
         case 'revision':
           if (empty($result)) {
             throw new ArcanistUsageException(
               pht(
                 'There is no revision %s.',
                 "D{$revision_id}"));
           }
           $this->checkRevisionOwnership(head($result));
           break;
         case 'reviewers':
           $away = array();
           foreach ($result as $user) {
             if (idx($user, 'currentStatus') != 'away') {
               continue;
             }
 
             $username = $user['userName'];
             $real_name = $user['realName'];
 
             if (strlen($real_name)) {
               $name = pht('%s (%s)', $username, $real_name);
             } else {
               $name = pht('%s', $username);
             }
 
             $away[] = array(
               'name' => $name,
               'until' => $user['currentStatusUntil'],
             );
           }
 
           if ($away) {
             if (count($away) == count($reviewers)) {
               $earliest_return = min(ipull($away, 'until'));
 
               $message = pht(
                 'All reviewers are away until %s:',
                 date('l, M j Y', $earliest_return));
             } else {
               $message = pht('Some reviewers are currently away:');
             }
 
             echo tsprintf(
               "%s\n\n",
               $message);
 
             $list = id(new PhutilConsoleList());
             foreach ($away as $spec) {
               $list->addItem(
                 pht(
                   '%s (until %s)',
                   $spec['name'],
                   date('l, M j Y', $spec['until'])));
             }
 
             echo tsprintf(
               '%B',
               $list->drawConsoleString());
 
             $confirm = pht('Continue even though reviewers are unavailable?');
             if (!phutil_console_confirm($confirm)) {
               throw new ArcanistUsageException(
                 pht('Specify available reviewers and retry.'));
             }
           }
           break;
       }
     }
 
   }
 
 
   /**
    * @task message
    */
   private function getUpdateMessage(array $fields, $template = '') {
     if ($this->getArgument('raw')) {
       throw new ArcanistUsageException(
         pht(
           "When using '%s' to update a revision, specify an update message ".
           "with '%s'. (Normally, we'd launch an editor to ask you for a ".
           "message, but can not do that because stdin is the diff source.)",
           '--raw',
           '--message'));
     }
 
     // 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();
 
       $comments = phutil_string_cast($comments);
       $comments = rtrim($comments);
 
       $template = sprintf(
         "%s\n\n# %s\n#\n# %s\n# %s\n#\n# %s\n#  $ %s\n\n",
         $comments,
         pht(
           'Updating %s: %s',
           "D{$fields['revisionID']}",
           $fields['title']),
         pht(
           'Enter a brief description of the changes included in this update.'),
         pht('The first line is used as subject, next lines as comment.'),
         pht('If you intended to create a new revision, use:'),
         'arc diff --create');
     }
 
     $comments = $this->newInteractiveEditor($template)
       ->setName('differential-update-comments')
       ->setTaskMessage(pht(
         'Update the revision comments, then save and exit.'))
       ->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[] = pht('Reviewers: %s', $this->getArgument('reviewers'));
     }
     if ($this->getArgument('cc')) {
       $faux_message[] = pht('CC: %s', $this->getArgument('cc'));
     }
 
     // NOTE: For now, this isn't a real field, so it just ends up as the first
     // part of the summary.
     $depends_ref = $this->getDependsOnRevisionRef();
     if ($depends_ref) {
       $faux_message[] = pht(
         'Depends on %s. ',
         $depends_ref->getMonogram());
     }
 
     // See T12069. After T10312, the first line of a message is always parsed
     // as a title. Add a placeholder so "Reviewers" and "CC" are never the
     // first line.
     $placeholder_title = pht('<placeholder>');
 
     if ($faux_message) {
       array_unshift($faux_message, $placeholder_title);
       $faux_message = implode("\n\n", $faux_message);
       $local = array(
         '(Flags)     ' => array(
           'message' => $faux_message,
           'summary' => pht('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'];
       $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[] = pht(
           'NOTE: commit %s could not be completely parsed:',
           $frev);
         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 ($title === $placeholder_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.
 
     $hashes = $this->loadActiveDiffLocalCommitHashes();
     $hashes = array_fuse($hashes);
 
     $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;
     }
 
     $hashes = $this->loadActiveDiffLocalCommitHashes();
     $hashes = array_fuse($hashes);
 
     $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);
       $text = head(explode("\n", $text));
       $default[] = '  - '.$text."\n";
     }
 
     return implode('', $default);
   }
 
   private function loadActiveDiffLocalCommitHashes() {
     // The older "differential.querydiffs" method includes the full diff text,
     // which can be very slow for large diffs. If we can, try to use
     // "differential.diff.search" instead.
 
     // We expect this to fail if the Phabricator version on the server is
     // older than April 2018 (D19386), which introduced the "commits"
     // attachment for "differential.revision.search".
 
     // TODO: This can be optimized if we're able to learn the "revisionPHID"
     // before we get here. See PHI1104.
 
     try {
       $revisions_raw = $this->getConduit()->callMethodSynchronous(
         'differential.revision.search',
         array(
           'constraints' => array(
             'ids' => array(
               $this->revisionID,
             ),
           ),
         ));
 
       $revisions = $revisions_raw['data'];
       $revision = head($revisions);
       if ($revision) {
         $revision_phid = $revision['phid'];
 
         $diffs_raw = $this->getConduit()->callMethodSynchronous(
           'differential.diff.search',
           array(
             'constraints' => array(
               'revisionPHIDs' => array(
                 $revision_phid,
               ),
             ),
             'attachments' => array(
               'commits' => true,
             ),
             'limit' => 1,
           ));
 
         $diffs = $diffs_raw['data'];
         $diff = head($diffs);
 
         if ($diff) {
           $commits = idxv($diff, array('attachments', 'commits', 'commits'));
           if ($commits !== null) {
             $hashes = ipull($commits, 'identifier');
             return array_values($hashes);
           }
         }
       }
     } catch (Exception $ex) {
       // If any of this fails, fall back to the older method below.
     }
 
     $current_diff = $this->getConduit()->callMethodSynchronous(
       'differential.querydiffs',
       array(
         'revisionIDs' => array($this->revisionID),
       ));
     $current_diff = head($current_diff);
 
     $properties = idx($current_diff, 'properties', array());
     $local = idx($properties, 'local:commits', array());
     $hashes = ipull($local, 'commit');
 
     return array_values($hashes);
   }
 
 
 /* -(  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',
     );
     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',
     );
     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
 
       }
     }
 
     $data = array(
       'sourceMachine'             => php_uname('n'),
       'sourcePath'                => $source_path,
       'branch'                    => $branch,
       'bookmark'                  => $bookmark,
       'sourceControlSystem'       => $vcs,
       'sourceControlPath'         => $base_path,
       'sourceControlBaseRevision' => $base_revision,
       'creationMethod'            => 'arc',
     );
 
     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 (!$this->hitAutotargets) {
       if ($this->unresolvedLint) {
         $this->updateDiffProperty(
           'arc:lint',
           json_encode($this->unresolvedLint));
       }
     }
   }
 
 
   /**
    * Update unit test information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateUnitDiffProperty() {
     if (!$this->hitAutotargets) {
       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));
   }
 
   private function updateOntoDiffProperty() {
     $onto = $this->getDiffOntoTargets();
 
     if (!$onto) {
       return;
     }
 
     $this->updateDiffProperty('arc:onto', json_encode($onto));
   }
 
   private function getDiffOntoTargets() {
     if ($this->isRawDiffSource()) {
       return null;
     }
 
     $api = $this->getRepositoryAPI();
 
     if (!($api instanceof ArcanistGitAPI)) {
       return null;
     }
 
     // If we track an upstream branch either directly or indirectly, use that.
     $branch = $api->getBranchName();
     if (strlen($branch)) {
       $upstream_path = $api->getPathToUpstream($branch);
       $remote_branch = $upstream_path->getRemoteBranchName();
       if ($remote_branch !== null) {
         return array(
           array(
             'type' => 'branch',
             'name' => $remote_branch,
             'kind' => 'upstream',
           ),
         );
       }
     }
 
     // If "arc.land.onto.default" is configured, use that.
     $config_key = 'arc.land.onto.default';
     $onto = $this->getConfigFromAnySource($config_key);
     if ($onto !== null) {
       return array(
         array(
           'type' => 'branch',
           'name' => $onto,
           'kind' => 'arc.land.onto.default',
         ),
       );
     }
 
     return null;
   }
 
   /**
    * 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() {
     id(new FutureIterator($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'];
 
     $prompt = pht(
       "You don't own revision %s: \"%s\". Normally, you should ".
       "only update revisions you own. You can \"Commandeer\" this revision ".
       "from the web interface if you want to become the owner.\n\n".
       "Update this revision anyway?",
       "D{$id}",
       $title);
 
     $ok = phutil_console_confirm($prompt, $default_no = true);
     if (!$ok) {
       throw new ArcanistUsageException(
         pht('Aborted update of revision: You are not 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'];
 
       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;
       }
 
       $type = $spec['type'];
       $size = strlen($spec['data']);
 
       $change->setMetadata("{$type}:file:size", $size);
 
       $mime = $this->getFileMimeType($spec['data']);
       if (preg_match('@^image/@', $mime)) {
         $change->setFileType($type_image);
       }
 
       $change->setMetadata("{$type}:file:mime-type", $mime);
     }
 
     $uploader = id(new ArcanistFileUploader())
       ->setConduitEngine($this->getConduitEngine());
 
     foreach ($need_upload as $key => $spec) {
       $ref = id(new ArcanistFileDataRef())
         ->setName($spec['name'])
         ->setData($spec['data']);
 
       $uploader->addFile($ref, $key);
     }
 
     $files = $uploader->uploadFiles();
 
     $errors = false;
     foreach ($files as $key => $file) {
       if ($file->getErrors()) {
         unset($files[$key]);
         $errors = true;
         echo pht(
           'Failed to upload binary "%s".',
           $file->getName());
       }
     }
 
     if ($errors) {
       $prompt = pht('Continue?');
       $ok = phutil_console_confirm($prompt, $default_no = false);
       if (!$ok) {
         throw new ArcanistUsageException(
           pht(
             'Aborted due to file upload failure. You can use %s '.
             'to skip binary uploads.',
             '--skip-binaries'));
       }
     }
 
     foreach ($files as $key => $file) {
       $spec = $need_upload[$key];
       $phid = $file->getPHID();
 
       $change = $spec['change'];
       $type = $spec['type'];
       $change->setMetadata("{$type}:binary-phid", $phid);
 
       echo pht('Uploaded binary data for "%s".', $file->getName())."\n";
     }
 
     echo pht('Upload complete.')."\n";
   }
 
   private function getFileMimeType($data) {
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $data);
     return Filesystem::getMimeType($tmp);
   }
 
   private function shouldOpenCreatedObjectsInBrowser() {
     return $this->getArgument('browse');
   }
 
   private function submitChangesToStagingArea($id) {
     $result = $this->pushChangesToStagingArea($id);
 
     // We'll either get a failure constant on error, or a list of pushed
     // refs on success.
     $ok = is_array($result);
 
     if ($ok) {
       $staging = array(
         'status' => self::STAGING_PUSHED,
         'refs' => $result,
       );
     } else {
       $staging = array(
         'status' => $result,
         'refs' => array(),
       );
     }
 
     $this->updateDiffProperty(
       'arc.staging',
       phutil_json_encode($staging));
   }
 
   private function pushChangesToStagingArea($id) {
     if ($this->getArgument('skip-staging')) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('Flag --skip-staging was specified.'));
       return self::STAGING_USER_SKIP;
     }
 
     if ($this->isRawDiffSource()) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('Raw changes can not be pushed to a staging area.'));
       return self::STAGING_DIFF_RAW;
     }
 
     if (!$this->getRepositoryPHID()) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('Unable to determine repository for this change.'));
       return self::STAGING_REPOSITORY_UNKNOWN;
     }
 
     $staging = $this->getRepositoryStagingConfiguration();
     if ($staging === null) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('The server does not support staging areas.'));
       return self::STAGING_REPOSITORY_UNAVAILABLE;
     }
 
     $supported = idx($staging, 'supported');
     if (!$supported) {
       $this->writeInfo(
         pht('SKIP STAGING'),
-        pht('Phabricator does not support staging areas for this repository.'));
+        pht('The server does not support staging areas for this repository.'));
       return self::STAGING_REPOSITORY_UNSUPPORTED;
     }
 
     $staging_uri = idx($staging, 'uri');
     if (!$staging_uri) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('No staging area is configured for this repository.'));
       return self::STAGING_REPOSITORY_UNCONFIGURED;
     }
 
     $api = $this->getRepositoryAPI();
     if (!($api instanceof ArcanistGitAPI)) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('This client version does not support staging this repository.'));
       return self::STAGING_CLIENT_UNSUPPORTED;
     }
 
     $commit = $api->getHeadCommit();
     $prefix = idx($staging, 'prefix', 'phabricator');
 
     $base_tag = "refs/tags/{$prefix}/base/{$id}";
     $diff_tag = "refs/tags/{$prefix}/diff/{$id}";
 
     $this->writeOkay(
       pht('PUSH STAGING'),
       pht('Pushing changes to staging area...'));
 
     $push_flags = array();
     if (version_compare($api->getGitVersion(), '1.8.2', '>=')) {
       $push_flags[] = '--no-verify';
     }
 
     $refs = array();
 
     $remote = array(
       'uri' => $staging_uri,
     );
 
     $is_lfs = $api->isGitLFSWorkingCopy();
 
     // If the base commit is a real commit, we're going to push it. We don't
     // use this, but pushing it to a ref reduces the amount of redundant work
     // that Git does on later pushes by helping it figure out that the remote
     // already has most of the history. See T10509.
 
     // In the future, we could avoid this push if the staging area is the same
     // as the main repository, or if the staging area is a virtual repository.
     // In these cases, the staging area should automatically have up-to-date
     // refs.
     $base_commit = $api->getSourceControlBaseRevision();
     if ($base_commit !== ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
       $refs[] = array(
         'ref' => $base_tag,
         'type' => 'base',
         'commit' => $base_commit,
         'remote' => $remote,
       );
     }
 
     // We're always going to push the change itself.
     $refs[] = array(
       'ref' => $diff_tag,
       'type' => 'diff',
       'commit' => $is_lfs ? $base_commit : $commit,
       'remote' => $remote,
     );
 
     $ref_list = array();
     foreach ($refs as $ref) {
       $ref_list[] = $ref['commit'].':'.$ref['ref'];
     }
 
     $err = phutil_passthru(
       'git push %Ls -- %s %Ls',
       $push_flags,
       $staging_uri,
       $ref_list);
 
     if ($err) {
       $this->writeWarn(
         pht('STAGING FAILED'),
         pht('Unable to push changes to the staging area.'));
 
       throw new ArcanistUsageException(
         pht(
           'Failed to push changes to staging area. Correct the issue, or '.
           'use --skip-staging to skip this step.'));
     }
 
     if ($is_lfs) {
       $ref = '+'.$commit.':'.$diff_tag;
       $err = phutil_passthru(
         'git push -- %s %s',
         $staging_uri,
         $ref);
 
       if ($err) {
         $this->writeWarn(
           pht('STAGING FAILED'),
           pht('Unable to push lfs changes to the staging area.'));
 
         throw new ArcanistUsageException(
           pht(
             'Failed to push lfs changes to staging area. Correct the issue, '.
             'or use --skip-staging to skip this step.'));
       }
     }
 
     return $refs;
   }
 
 
   /**
    * Try to upload lint and unit test results into modern Harbormaster build
    * targets.
    *
    * @return bool True if everything was uploaded to build targets.
    */
   private function updateAutotargets($diff_phid, $unit_result) {
     $lint_key = 'arcanist.lint';
     $unit_key = 'arcanist.unit';
 
     try {
       $result = $this->getConduit()->callMethodSynchronous(
         'harbormaster.queryautotargets',
         array(
           'objectPHID' => $diff_phid,
           'targetKeys' => array(
             $lint_key,
             $unit_key,
           ),
         ));
       $targets = idx($result, 'targetMap', array());
     } catch (Exception $ex) {
       return false;
     }
 
     $futures = array();
 
     $lint_target = idx($targets, $lint_key);
     if ($lint_target) {
       $lint = nonempty($this->unresolvedLint, array());
       foreach ($lint as $key => $message) {
         $lint[$key] = $this->getModernLintDictionary($message);
       }
 
       // Consider this target to have failed if there are any unresolved
       // errors or warnings.
       $type = 'pass';
       foreach ($lint as $message) {
         switch (idx($message, 'severity')) {
           case ArcanistLintSeverity::SEVERITY_WARNING:
           case ArcanistLintSeverity::SEVERITY_ERROR:
             $type = 'fail';
             break;
         }
       }
 
       $futures[] = $this->getConduit()->callMethod(
         'harbormaster.sendmessage',
         array(
           'buildTargetPHID' => $lint_target,
           'lint' => array_values($lint),
           'type' => $type,
         ));
     }
 
     $unit_target = idx($targets, $unit_key);
     if ($unit_target) {
       $unit = nonempty($this->testResults, array());
       foreach ($unit as $key => $message) {
         $unit[$key] = $this->getModernUnitDictionary($message);
       }
 
       $type = ArcanistUnitWorkflow::getHarbormasterTypeFromResult($unit_result);
 
       $futures[] = $this->getConduit()->callMethod(
         'harbormaster.sendmessage',
         array(
           'buildTargetPHID' => $unit_target,
           'unit' => array_values($unit),
           'type' => $type,
         ));
     }
 
     try {
       foreach (new FutureIterator($futures) as $future) {
         $future->resolve();
       }
       return true;
     } catch (Exception $ex) {
       // TODO: Eventually, we should expect these to succeed if we get this
       // far, but just log errors for now.
       phlog($ex);
       return false;
     }
   }
 
   private function getDependsOnRevisionRef() {
     // TODO: Restore this behavior after updating for toolsets. Loading the
     // required hardpoints currently depends on a "WorkingCopy" existing.
     return null;
 
     $api = $this->getRepositoryAPI();
     $base_ref = $api->getBaseCommitRef();
 
     $state_ref = id(new ArcanistWorkingCopyStateRef())
       ->setCommitRef($base_ref);
 
     $this->loadHardpoints(
       $state_ref,
       ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS);
 
     $revision_refs = $state_ref->getRevisionRefs();
     $viewer_phid = $this->getUserPHID();
 
     foreach ($revision_refs as $key => $revision_ref) {
       // Don't automatically depend on closed revisions.
       if ($revision_ref->isClosed()) {
         unset($revision_refs[$key]);
         continue;
       }
 
       // Don't automatically depend on revisions authored by other users.
       if ($revision_ref->getAuthorPHID() != $viewer_phid) {
         unset($revision_refs[$key]);
         continue;
       }
     }
 
     if (!$revision_refs) {
       return null;
     }
 
     if (count($revision_refs) > 1) {
       return null;
     }
 
     return head($revision_refs);
   }
 
 }
diff --git a/src/workflow/ArcanistInstallCertificateWorkflow.php b/src/workflow/ArcanistInstallCertificateWorkflow.php
index a352b21d..49bb5045 100644
--- a/src/workflow/ArcanistInstallCertificateWorkflow.php
+++ b/src/workflow/ArcanistInstallCertificateWorkflow.php
@@ -1,239 +1,238 @@
 <?php
 
 /**
  * Installs arcanist certificates.
  */
 final class ArcanistInstallCertificateWorkflow extends ArcanistWorkflow {
 
   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/").
+          Installs Conduit credentials into your ~/.arcrc for the given server.
+          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://devtools.example.com/").
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'uri',
     );
   }
 
   protected function shouldShellComplete() {
     return false;
   }
 
   public function requiresConduit() {
     return false;
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
   public function run() {
     $console = PhutilConsole::getConsole();
 
     $uri = $this->determineConduitURI();
     $this->setConduitURI($uri);
     $configuration_manager = $this->getConfigurationManager();
 
     $config = $configuration_manager->readUserConfigurationFile();
 
     $this->writeInfo(
       pht('CONNECT'),
       pht(
         'Connecting to "%s"...',
         $uri));
 
     $conduit = $this->establishConduit()->getConduit();
     try {
       $conduit->callMethodSynchronous('conduit.ping', array());
     } catch (Exception $ex) {
       throw new ArcanistUsageException(
         pht(
           'Failed to connect to server (%s): %s',
           $uri,
           $ex->getMessage()));
     }
 
     $token_uri = new PhutilURI($uri);
     $token_uri->setPath('/conduit/token/');
 
     // Check if this server supports the more modern token-based login.
     $is_token_auth = false;
     try {
       $capabilities = $conduit->callMethodSynchronous(
         'conduit.getcapabilities',
         array());
       $auth = idx($capabilities, 'authentication', array());
       if (in_array('token', $auth)) {
         $token_uri->setPath('/conduit/login/');
         $is_token_auth = true;
       }
     } catch (Exception $ex) {
       // Ignore.
     }
 
-    echo phutil_console_format("**%s**\n", pht('LOGIN TO PHABRICATOR'));
+    echo phutil_console_format("**%s**\n", pht('LOG IN'));
     echo phutil_console_format(
       "%s\n\n%s\n\n%s",
       pht(
-        'Open this page in your browser and login to '.
-        'Phabricator if necessary:'),
+        'Open this page in your browser and log in if necessary:'),
       $token_uri,
       pht('Then paste the API Token on that page below.'));
 
     do {
       $token = phutil_console_prompt(pht('Paste API Token from that page:'));
       $token = trim($token);
       if (strlen($token)) {
         break;
       }
     } while (true);
 
     if ($is_token_auth) {
       if (strlen($token) != 32) {
         throw new ArcanistUsageException(
           pht(
             'The token "%s" is not formatted correctly. API tokens should '.
             'be 32 characters long. Make sure you visited the correct URI '.
             'and copy/pasted the token correctly.',
             $token));
       }
 
       if (strncmp($token, 'api-', 4) == 0) {
         echo pht(
           'You are installing a standard API token, but a CLI API token '.
           'was expected. If you\'re writing a script, consider passing the '.
           'token at runtime with --conduit-token instead of installing it.');
         if (!phutil_console_confirm(pht('Install this token anyway?'))) {
           throw new ArcanistUsageException(pht('Not installing API token.'));
         }
       } else if (strncmp($token, 'cli-', 4) !== 0) {
         throw new ArcanistUsageException(
           pht(
             'The token "%s" is not formatted correctly. Valid API tokens '.
             'should begin "cli-" and be 32 characters long. Make sure you '.
             'visited the correct URI and copy/pasted the token correctly.',
             $token));
       }
 
       $conduit->setConduitToken($token);
       try {
         $conduit->callMethodSynchronous('user.whoami', array());
       } catch (Exception $ex) {
         throw new ArcanistUsageException(
           pht(
             'The token "%s" is not a valid API Token. The server returned '.
             'this response when trying to use it as a token: %s',
             $token,
             $ex->getMessage()));
       }
 
       $config['hosts'][$uri] = array(
         'token' => $token,
       );
     } else {
       echo "\n";
       echo pht('Downloading authentication certificate...')."\n";
       $info = $conduit->callMethodSynchronous(
         'conduit.getcertificate',
         array(
           'token' => $token,
           'host'  => $uri,
         ));
 
       $user = $info['username'];
       echo pht("Installing certificate for '%s'...", $user)."\n";
       $config['hosts'][$uri] = array(
         'user' => $user,
         'cert' => $info['certificate'],
       );
     }
 
     echo pht('Writing %s...', '~/.arcrc')."\n";
     $configuration_manager->writeUserConfigurationFile($config);
 
     if ($is_token_auth) {
       echo phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         pht('SUCCESS!'),
         pht('API Token installed.'));
     } else {
       echo phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         pht('SUCCESS!'),
         pht('Certificate installed.'));
     }
 
     return 0;
   }
 
   private function determineConduitURI() {
     $uri = $this->getArgument('uri');
     if (count($uri) > 1) {
       throw new ArcanistUsageException(pht('Specify at most one URI.'));
     } else if (count($uri) == 1) {
       $uri = reset($uri);
     } else {
       $conduit_uri = $this->getConduitURI();
       if (!$conduit_uri) {
         throw new ArcanistUsageException(
           pht(
             'Specify an explicit URI or run this command from within a '.
             'project which is configured with a %s.',
             '.arcconfig'));
       }
       $uri = $conduit_uri;
     }
 
-    $example = 'https://phabricator.example.com/';
+    $example = 'https://devtools.example.com/';
 
     $uri_object = new PhutilURI($uri);
     $protocol = $uri_object->getProtocol();
     if (!$protocol || !$uri_object->getDomain()) {
       throw new ArcanistUsageException(
         pht(
           'Server URI "%s" must include a protocol and domain. It should be '.
           'in the form "%s".',
           $uri,
           $example));
     }
 
     $protocol = $uri_object->getProtocol();
     switch ($protocol) {
       case 'http':
       case 'https':
         break;
       default:
         throw new ArcanistUsageException(
           pht(
             'Server URI "%s" must include the "http" or "https" protocol. '.
             'It should be in the form "%s".',
             $uri,
             $example));
     }
 
     $uri_object->setPath('/api/');
 
     return (string)$uri_object;
   }
 
 }
diff --git a/src/workflow/ArcanistLiberateWorkflow.php b/src/workflow/ArcanistLiberateWorkflow.php
index 9d6b476d..f4ed4fd2 100644
--- a/src/workflow/ArcanistLiberateWorkflow.php
+++ b/src/workflow/ArcanistLiberateWorkflow.php
@@ -1,243 +1,243 @@
 <?php
 
 final class ArcanistLiberateWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'liberate';
   }
 
   public function getWorkflowInformation() {
     // TOOLSETS: Expand this help.
 
     $help = pht(<<<EOTEXT
-Create or update an Arcanist library.
+Create or update a library.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(
-        pht('Create or update an Arcanist library.'))
+        pht('Create or update a library.'))
       ->addExample(pht('**liberate**'))
       ->addExample(pht('**liberate** [__path__]'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('clean')
         ->setHelp(
           pht('Perform a clean rebuild, ignoring caches. Thorough, but slow.')),
       $this->newWorkflowArgument('argv')
         ->setWildcard(true)
         ->setIsPathArgument(true),
     );
   }
 
   protected function newPrompts() {
     return array(
       $this->newPrompt('arc.liberate.create')
         ->setDescription(
           pht(
             'Confirms creation of a new library.')),
     );
   }
 
 
   public function runWorkflow() {
     $log = $this->getLogEngine();
 
     $argv = $this->getArgument('argv');
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         pht(
           'Provide only one path to "arc liberate". The path should identify '.
           'a directory where you want to create or update a library.'));
     } else if (!$argv) {
       $log->writeStatus(
         pht('SCAN'),
         pht('Searching for libraries in the current working directory...'));
 
       $init_files = id(new FileFinder(getcwd()))
         ->withPath('*/__phutil_library_init__.php')
         ->find();
 
       if (!$init_files) {
         throw new ArcanistUsageException(
           pht(
             'Unable to find any libraries under the current working '.
             'directory. To create a library, provide a path.'));
       }
 
       $paths = array();
       foreach ($init_files as $init) {
         $paths[] = Filesystem::resolvePath(dirname($init));
       }
     } else {
       $paths = array(
         Filesystem::resolvePath(head($argv)),
       );
     }
 
     $any_errors = false;
     foreach ($paths as $path) {
       $log->writeStatus(
         pht('WORK'),
         pht(
           'Updating library: %s',
           Filesystem::readablePath($path).DIRECTORY_SEPARATOR));
       $exit_code = $this->liberatePath($path);
       if ($exit_code !== 0) {
         $any_errors = true;
         $log->writeError(
           pht('ERROR'),
           pht('Failed to update library: %s', $path));
       }
     }
 
     if (!$any_errors) {
       $log->writeSuccess(
         pht('DONE'),
         pht('Updated %s librarie(s).', phutil_count($paths)));
     }
 
     return 0;
   }
 
   /**
    * @return  int The exit code of running the rebuild-map.php script, which
    *              will be 0 to indicate success or non-zero for failure.
    */
   private function liberatePath($path) {
     if (!Filesystem::pathExists($path.'/__phutil_library_init__.php')) {
       echo tsprintf(
         "%s\n",
         pht(
           'No library currently exists at the path "%s"...',
           $path));
       $this->liberateCreateDirectory($path);
       return $this->liberateCreateLibrary($path);
     }
 
     $version = $this->getLibraryFormatVersion($path);
     switch ($version) {
       case 1:
         throw new ArcanistUsageException(
           pht(
             'This very old library is no longer supported.'));
       case 2:
         return $this->liberateVersion2($path);
       default:
         throw new ArcanistUsageException(
           pht("Unknown library version '%s'!", $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;
   }
 
   /**
    * @return  int The exit code of running the rebuild-map.php script, which
    *              will be 0 to indicate success or non-zero for failure.
    */
   private function liberateVersion2($path) {
     $bin = $this->getScriptPath('support/lib/rebuild-map.php');
 
     $argv = array();
     if ($this->getArgument('clean')) {
       $argv[] = '--drop-cache';
     }
 
     return phutil_passthru(
       'php -f %R -- %Ls %R',
       $bin,
       $argv,
       $path);
   }
 
   private function liberateCreateDirectory($path) {
     if (Filesystem::pathExists($path)) {
       if (!is_dir($path)) {
         throw new ArcanistUsageException(
           pht(
             'Provide a directory to create or update a libphutil library in.'));
       }
       return;
     }
 
     echo tsprintf(
       "%!\n%W\n",
       pht('NEW LIBRARY'),
       pht(
         'The directory "%s" does not exist. Do you want to create it?',
         $path));
 
     $query = pht('Create new library?');
 
     $this->getPrompt('arc.liberate.create')
       ->setQuery($query)
       ->execute();
 
     execx('mkdir -p %R', $path);
   }
 
   /**
    * @return  int The exit code of running the rebuild-map.php script, which
    *              will be 0 to indicate success or non-zero for failure.
    */
   private function liberateCreateLibrary($path) {
     $init_path = $path.'/__phutil_library_init__.php';
     if (Filesystem::pathExists($init_path)) {
       return 0;
     }
 
     echo pht("Creating new libphutil library in '%s'.", $path)."\n";
 
     do {
       echo pht('Choose a name for the new library.')."\n";
       $name = phutil_console_prompt(
         pht('What do you want to name this library?'));
 
       if (preg_match('/^[a-z-]+$/', $name)) {
         break;
       } else {
         echo phutil_console_format(
           "%s\n",
           pht(
           'Library name should contain only lowercase letters and hyphens.'));
       }
     } while (true);
 
     $template =
       "<?php\n\n".
       "phutil_register_library('{$name}', __FILE__);\n";
 
     echo pht(
       "Writing '%s' to '%s'...\n",
       '__phutil_library_init__.php',
       $path);
     Filesystem::writeFile($init_path, $template);
     return $this->liberateVersion2($path);
   }
 
 
   private function getScriptPath($script) {
     $root = dirname(phutil_get_library_root('arcanist'));
     return $root.'/'.$script;
   }
 
 }
diff --git a/src/workflow/ArcanistPatchWorkflow.php b/src/workflow/ArcanistPatchWorkflow.php
index 66d5c32c..acfb06ee 100644
--- a/src/workflow/ArcanistPatchWorkflow.php
+++ b/src/workflow/ArcanistPatchWorkflow.php
@@ -1,1146 +1,1146 @@
 <?php
 
 /**
  * Applies changes from Differential or a file to the working copy.
  */
 final class ArcanistPatchWorkflow extends ArcanistWorkflow {
 
   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' => pht(
           "Apply changes from a Differential revision, using the most recent ".
           "diff that has been attached to it. You can run '%s' as a shorthand.",
           'arc patch D12345'),
       ),
       'diff' => array(
         'param' => 'diff_id',
         'help' => pht(
           'Apply changes from a Differential diff. Normally you want to use '.
           '%s 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.',
           '--revision'),
       ),
       'arcbundle' => array(
         'param' => 'bundlefile',
         'paramtype' => 'file',
         'help' => pht(
           "Apply changes from an arc bundle generated with '%s'.",
           'arc export'),
       ),
       'patch' => array(
         'param' => 'patchfile',
         'paramtype' => 'file',
         'help' => pht(
           'Apply changes from a git patchfile or unified patchfile.'),
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' => pht(
           'Attempt to convert non UTF-8 patch into specified encoding.'),
       ),
       'update' => array(
         'supports' => array('git', 'svn', 'hg'),
         'help' => pht(
           'Update the local working copy before applying the patch.'),
         'conflicts' => array(
           'nobranch' => true,
           'bookmark' => true,
         ),
       ),
       'nocommit' => array(
         'supports' => array('git', 'hg'),
         'help' => pht(
           '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'),
         'help' => pht(
           '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'),
         'help' => pht(
           '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' => pht('Do not run any sanity checks.'),
       ),
       '*' => 'name',
     );
   }
 
   protected function didParseArguments() {
     $arguments = array(
       'revision' => self::SOURCE_REVISION,
       'diff' => self::SOURCE_DIFF,
       'arcbundle' => self::SOURCE_BUNDLE,
       'patch' => self::SOURCE_PATCH,
       'name' => self::SOURCE_REVISION,
     );
 
     $sources = array();
     foreach ($arguments as $key => $source_type) {
       $value = $this->getArgument($key);
       if (!$value) {
         continue;
       }
 
       switch ($key) {
         case 'revision':
           $value = $this->normalizeRevisionID($value);
           break;
         case 'name':
           if (count($value) > 1) {
             throw new ArcanistUsageException(
               pht('Specify at most one revision name.'));
           }
           $value = $this->normalizeRevisionID(head($value));
           break;
       }
 
       $sources[] = array(
         $source_type,
         $value,
       );
     }
 
     if (!$sources) {
       throw new ArcanistUsageException(
         pht(
           'You must specify changes to apply to the working copy with '.
           '"D12345", "--revision", "--diff", "--arcbundle", or "--patch".'));
     }
 
     if (count($sources) > 1) {
       throw new ArcanistUsageException(
         pht(
           'Options "D12345", "--revision", "--diff", "--arcbundle" and '.
           '"--patch" are mutually exclusive. Choose exactly one patch '.
           'source.'));
     }
 
     $source = head($sources);
 
     $this->source = $source[0];
     $this->sourceParam = $source[1];
   }
 
   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(
           "%s\n",
           pht(
             'Branch name %s already exists; trying a new name.',
             $proposed_name));
         continue;
       } else {
         $branch_name = $proposed_name;
         break;
       }
     }
 
     if (!$branch_name) {
       throw new Exception(
         pht(
           '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;
     $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(
           "%s\n",
           pht(
             'Bookmark name %s already exists; trying a new name.',
             $proposed_name));
         continue;
       } else {
         $bookmark_name = $proposed_name;
         break;
       }
     }
 
     if (!$bookmark_name) {
       throw new Exception(
         pht(
           '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);
       }
 
       // Synchronize submodule state, since the checkout may have modified
       // submodule references. See PHI1083.
 
       // Note that newer versions of "git checkout" include a
       // "--recurse-submodules" flag which accomplishes this goal a little
       // more simply. For now, use the more compatible form.
       $repository_api->execPassthru('submodule update --init --recursive');
 
       echo phutil_console_format(
         "%s\n",
         pht(
           'Created and checked out branch %s.',
           $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 pht("Updating to the revision's base commit")."\n";
         $repository_api->execPassthru('update %s', $base_revision);
       }
 
       $repository_api->execxLocal('bookmark %s', $branch_name);
 
       echo phutil_console_format(
         "%s\n",
         pht(
           'Created and checked out bookmark %s.',
           $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 pht('Updating working copy...')."\n";
     $this->getRepositoryAPI()->updateWorkingCopy();
     echo pht('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(
                 pht('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 (!$has_base_revision) {
       if ($repository_api instanceof ArcanistGitAPI) {
         echo phutil_console_format(
           "<bg:blue>** %s **</bg> %s\n",
           pht('INFO'),
           pht('Base commit is not in local repository; trying to fetch.'));
         $repository_api->execManualLocal('fetch --quiet --all');
         $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(
                 pht(
                   "Patch deletes file '%s', but the file does not exist in ".
                   "the working copy. Continue anyway?",
                   $path));
               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 = pht('copies');
               } else {
                 $verbs = pht('moves');
               }
               $ok = phutil_console_confirm(
                 pht(
                   "Patch %s '%s' to '%s', but source path does not exist ".
                   "in the working copy. Continue anyway?",
                   $verbs,
                   $path,
                   $cpath));
               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>** %s **</bg> %s\n",
           pht('OKAY'),
           pht('Successfully applied patch to the working copy.'));
       } else {
         echo phutil_console_format(
           "\n\n<bg:yellow>** %s **</bg> %s\n",
           pht('WARNING'),
           pht(
             "Some hunks could not be applied cleanly by the unix '%s' ".
             "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 '%s', and then try to apply it by ".
             "fiddling with options to '%s' (particularly, %s), or manually. ".
             "The output above, from '%s', may be helpful in ".
             "figuring out what went wrong.",
             'patch',
             'arc export --unified',
             'patch',
             '-p',
             'patch'));
       }
 
       return $patch_err;
     } else if ($repository_api instanceof ArcanistGitAPI) {
 
       $patchfile = new TempFile();
       Filesystem::writeFile($patchfile, $bundle->toGitPatch());
 
       $passthru = new PhutilExecPassthru(
         'git apply --whitespace nowarn --index --reject -- %s',
         $patchfile);
       $passthru->setCWD($repository_api->getPath());
       $err = $passthru->resolve();
 
       if ($err) {
         echo phutil_console_format(
           "\n<bg:red>** %s **</bg>\n",
           pht('Patch Failed!'));
 
         // 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(pht('Unable to apply patch!'));
       }
 
       // See PHI1083 and PHI648. If the patch applied changes to submodules,
       // it only updates the submodule pointer, not the actual submodule. We're
       // left with the pointer update staged in the index, and the unmodified
       // submodule on disk.
 
       // If we then "git commit --all" or "git add --all", the unmodified
       // submodule on disk is added to the index as a change, which effectively
       // undoes the patch we just applied and reverts the submodule back to
       // the previous state.
 
       // To avoid this, do a submodule update before we continue.
 
       // We could also possibly skip the "--all" flag so we don't have to do
       // this submodule update, but we want to leave the working copy in a
       // clean state anyway, so we're going to have to do an update at some
       // point. This usually doesn't cost us anything.
       $repository_api->execPassthru('submodule update --init --recursive');
 
       if ($this->shouldCommit()) {
         $flags = array();
         if ($bundle->getFullAuthor()) {
           $flags[] = csprintf('--author=%s', $bundle->getFullAuthor());
         }
 
         $commit_message = $this->getCommitMessage($bundle);
 
         $future = $repository_api->execFutureLocal(
           'commit -a %Ls -F - --no-verify',
           $flags);
         $future->write($commit_message);
         $future->resolvex();
 
         $this->writeOkay(
           pht('COMMITTED'),
           pht('Successfully committed patch.'));
       } else {
         $this->writeOkay(
           pht('APPLIED'),
           pht('Successfully applied patch.'));
       }
 
       if ($this->canBranch() &&
           !$this->shouldBranch() &&
           $this->shouldCommit() && $has_base_revision) {
 
         // See PHI1083 and PHI648. Synchronize submodule state after mutating
         // the working copy.
 
         $repository_api->execxLocal('checkout %s --', $original_branch);
         $repository_api->execPassthru('submodule update --init --recursive');
 
         $ex = null;
         try {
           $repository_api->execxLocal('cherry-pick -- %s', $new_branch);
           $repository_api->execPassthru('submodule update --init --recursive');
         } catch (Exception $ex) {
           // do nothing
         }
 
         $repository_api->execxLocal('branch -D -- %s', $new_branch);
 
         if ($ex) {
           echo phutil_console_format(
             "\n<bg:red>** %s**</bg>\n",
             pht('Cherry Pick Failed!'));
           throw $ex;
         }
       }
 
     } 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>** %s **</bg>\n",
           pht('Patch Failed!'));
         $stderr = $ex->getStderr();
         if (preg_match('/case-folding collision/', $stderr)) {
           echo phutil_console_wrap(
             phutil_console_format(
               "\n<bg:yellow>** %s **</bg> %s\n",
               pht('WARNING'),
               pht(
                 "This patch may have failed because it attempts to change ".
                 "the case of a filename (for instance, from '%s' to '%s'). ".
                 "Mercurial cannot apply patches like this on case-insensitive ".
                 "filesystems. You must apply this patch manually.",
                 'example.c',
                 'Example.c')));
         }
         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>** %s**</bg>\n",
                 pht('Rebase onto %s failed!', $original_branch)));
           }
         }
 
         $verb = pht('committed');
       } else {
         $verb = pht('applied');
       }
 
       echo phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         pht('OKAY'),
         pht('Successfully %s patch.', $verb));
     } else {
       throw new Exception(pht('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 = pht(
-        '  Note arcanist failed to load the commit message '.
-        'from differential for revision %s.',
+        '  NOTE: Failed to load the commit message from Differential (for '.
+        'revision "%s".)',
         "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 = sprintf(
         "\n\n# %s%s\n",
         pht(
           '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 %s flag.',
           '--nocommit'),
         $prompt_message);
 
       $commit_message = $this->newInteractiveEditor($template)
         ->setName('arcanist-patch-commit-message')
         ->setTaskMessage(pht(
           'Supply a commit message for this patch, then save and exit.'))
         ->editInteractively();
 
       $commit_message = ArcanistCommentRemover::removeComments($commit_message);
       if (!strlen(trim($commit_message))) {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $commit_message;
   }
 
   protected 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 = pht(
           '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->getNodesInTopologicalOrder();
         $phids = array_reverse($phids);
         $okay = true;
       }
 
       if (!$okay) {
         return;
       }
 
       $dep_on_revs = $this->getConduit()->callMethodSynchronous(
         'differential.query',
         array(
           'phids' => $phids,
         ));
       $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 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'];
           }
           if ($source_revision) {
             $source_base_rev_str = $source_base_rev.
               ' \ 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);
 
         $ok = phutil_console_confirm(
           pht(
             'This diff is against commit %s, but the commit is nowhere '.
             'in the working copy. Try to apply it against the current '.
             'working copy state? (%s)',
             $bundle_base_rev_str,
             $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/ArcanistUpgradeWorkflow.php b/src/workflow/ArcanistUpgradeWorkflow.php
index 7759c10a..14f45af9 100644
--- a/src/workflow/ArcanistUpgradeWorkflow.php
+++ b/src/workflow/ArcanistUpgradeWorkflow.php
@@ -1,133 +1,133 @@
 <?php
 
 final class ArcanistUpgradeWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'upgrade';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
-Upgrade Arcanist to the latest version.
+Upgrade this program to the latest version.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
-      ->setSynopsis(pht('Upgrade Arcanist to the latest version.'))
+      ->setSynopsis(pht('Upgrade this program to the latest version.'))
       ->addExample(pht('**upgrade**'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array();
   }
 
   public function runWorkflow() {
     $log = $this->getLogEngine();
 
     $roots = array(
       'arcanist' => dirname(phutil_get_library_root('arcanist')),
     );
 
     $supported_branches = array(
       'master',
       'stable',
     );
     $supported_branches = array_fuse($supported_branches);
 
     foreach ($roots as $library => $root) {
       $log->writeStatus(
         pht('PREPARING'),
         pht(
           'Preparing to upgrade "%s"...',
           $library));
 
       $working_copy = ArcanistWorkingCopy::newFromWorkingDirectory($root);
 
       $repository_api = $working_copy->getRepositoryAPI();
       $is_git = ($repository_api instanceof ArcanistGitAPI);
 
       if (!$is_git) {
         throw new PhutilArgumentUsageException(
           pht(
-            'The "arc upgrade" workflow uses "git pull" to upgrade '.
-            'Arcanist, but the "arcanist/" directory  (in "%s") is not a Git '.
-            'working copy. You must leave "arcanist/" as a Git '.
-            'working copy to use "arc upgrade".',
+            'The "upgrade" workflow uses "git pull" to upgrade, but '.
+            'the software directory (in "%s") is not a Git working '.
+            'copy. You must leave this directory as a Git working copy to '.
+            'use "arc upgrade".',
             $root));
       }
 
       // NOTE: Don't use requireCleanWorkingCopy() here because it tries to
       // amend changes and generally move the workflow forward. We just want to
       // abort if there are local changes and make the user sort things out.
       $uncommitted = $repository_api->getUncommittedStatus();
       if ($uncommitted) {
         $message = pht(
           'You have uncommitted changes in the working copy ("%s") for this '.
           'library ("%s"):',
           $root,
           $library);
 
         $list = id(new PhutilConsoleList())
           ->setWrap(false)
           ->addItems(array_keys($uncommitted));
 
         id(new PhutilConsoleBlock())
           ->addParagraph($message)
           ->addList($list)
           ->addParagraph(
             pht(
               'Discard these changes before running "arc upgrade".'))
           ->draw();
 
         throw new PhutilArgumentUsageException(
           pht('"arc upgrade" can only upgrade clean working copies.'));
       }
 
       $branch_name = $repository_api->getBranchName();
       if (!isset($supported_branches[$branch_name])) {
         throw new PhutilArgumentUsageException(
           pht(
             'Library "%s" (in "%s") is on branch "%s", but this branch is '.
             'not supported for automatic upgrades. Supported branches are: '.
             '%s.',
             $library,
             $root,
             $branch_name,
             implode(', ', array_keys($supported_branches))));
       }
 
       $log->writeStatus(
         pht('UPGRADING'),
         pht(
           'Upgrading "%s" (on branch "%s").',
           $library,
           $branch_name));
 
       $command = csprintf(
         'git pull --rebase origin -- %R',
         $branch_name);
 
       $future = (new PhutilExecPassthru($command))
         ->setCWD($root);
 
       try {
         $this->newCommand($future)
           ->execute();
       } catch (Exception $ex) {
         // If we failed, try to go back to the old state, then throw the
         // original exception.
         exec_manual('git rebase --abort');
         throw $ex;
       }
     }
 
     $log->writeSuccess(
       pht('UPGRADED'),
-      pht('Your copy of Arcanist is now up to date.'));
+      pht('This software is now up to date.'));
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistUploadWorkflow.php b/src/workflow/ArcanistUploadWorkflow.php
index d888c464..fe2ff1bc 100644
--- a/src/workflow/ArcanistUploadWorkflow.php
+++ b/src/workflow/ArcanistUploadWorkflow.php
@@ -1,144 +1,144 @@
 <?php
 
 final class ArcanistUploadWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'upload';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
-Upload one or more files from local disk to Phabricator.
+Upload one or more files from local disk.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Upload files.'))
       ->addExample(pht('**upload** [__options__] -- __file__ [__file__ ...]'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('json')
         ->setHelp(pht('Output upload information in JSON format.')),
       $this->newWorkflowArgument('browse')
         ->setHelp(
           pht(
             'After the upload completes, open the files in a web browser.')),
       $this->newWorkflowArgument('temporary')
         ->setHelp(
           pht(
             'Mark the file as temporary. Temporary files will be '.
             'deleted after 24 hours.')),
       $this->newWorkflowArgument('paths')
         ->setWildcard(true)
         ->setIsPathArgument(true),
     );
   }
 
   public function runWorkflow() {
     if (!$this->getArgument('paths')) {
       throw new PhutilArgumentUsageException(
         pht('Specify one or more paths to files you want to upload.'));
     }
 
     $is_temporary = $this->getArgument('temporary');
     $is_json = $this->getArgument('json');
     $is_browse = $this->getArgument('browse');
     $paths = $this->getArgument('paths');
 
     $conduit = $this->getConduitEngine();
     $results = array();
 
     $uploader = id(new ArcanistFileUploader())
       ->setConduitEngine($conduit);
 
     foreach ($paths as $key => $path) {
       $file = id(new ArcanistFileDataRef())
         ->setName(basename($path))
         ->setPath($path);
 
       if ($is_temporary) {
         $expires_at = time() + phutil_units('24 hours in seconds');
         $file->setDeleteAfterEpoch($expires_at);
       }
 
       $uploader->addFile($file);
     }
 
     $files = $uploader->uploadFiles();
 
     $phids = array();
     foreach ($files as $file) {
       // TODO: This could be handled more gracefully.
       if ($file->getErrors()) {
         throw new Exception(implode("\n", $file->getErrors()));
       }
       $phids[] = $file->getPHID();
     }
 
     $symbols = $this->getSymbolEngine();
     $symbol_refs = $symbols->loadFilesForSymbols($phids);
 
     $refs = array();
     foreach ($symbol_refs as $symbol_ref) {
       $ref = $symbol_ref->getObject();
       if ($ref === null) {
         throw new Exception(
           pht(
             'Failed to resolve symbol ref "%s".',
             $symbol_ref->getSymbol()));
       }
       $refs[] = $ref;
     }
 
     if ($is_json) {
       $json = array();
 
       foreach ($refs as $key => $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
 
         $map = array(
           'argument' => $paths[$key],
           'id' => $ref->getID(),
           'phid' => $ref->getPHID(),
           'name' => $ref->getName(),
           'uri' => $uri,
         );
 
         $json[] = $map;
       }
 
       echo id(new PhutilJSON())->encodeAsList($json);
     } else {
       foreach ($refs as $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
         echo tsprintf(
           '%s',
           $ref->newRefView()
             ->setURI($uri));
       }
     }
 
     if ($is_browse) {
       $uris = array();
       foreach ($refs as $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
         $uris[] = $uri;
       }
       $this->openURIsInBrowser($uris);
     }
 
     return 0;
   }
 
   private function writeStatus($line) {
     $this->writeStatusMessage($line."\n");
   }
 
 }
diff --git a/src/workflow/ArcanistWorkWorkflow.php b/src/workflow/ArcanistWorkWorkflow.php
index 3696bb17..b837fbca 100644
--- a/src/workflow/ArcanistWorkWorkflow.php
+++ b/src/workflow/ArcanistWorkWorkflow.php
@@ -1,95 +1,95 @@
 <?php
 
 final class ArcanistWorkWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'work';
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('start')
         ->setParameter('symbol')
         ->setHelp(
           pht(
             'When creating a new branch or bookmark, use this as the '.
             'branch point.')),
       $this->newWorkflowArgument('symbol')
         ->setWildcard(true),
     );
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOHELP
 Begin or resume work on a branch, bookmark, task, or revision.
 
 The __symbol__ may be a branch or bookmark name, a revision name (like "D123"),
 a task name (like "T123"), or a new symbol.
 
 If you provide a symbol which currently does not identify any ongoing work,
-Arcanist will create a new branch or bookmark with the name you provide.
+a new branch or bookmark will be created with the name you provide.
 
-If you provide the name of an existing branch or bookmark, Arcanist will switch
-to that branch or bookmark.
+If you provide the name of an existing branch or bookmark, the working copy
+will be switched to that branch or bookmark.
 
-If you provide the name of a revision or task, Arcanist will look for a related
-branch or bookmark that exists in the working copy. If it finds one, it will
-switch to it. If it does not find one, it will attempt to create a new branch
-or bookmark.
+If you provide the name of a revision or task, the workflow will look for a
+related branch or bookmark that already exists in the working copy. If one is
+found, it will switch to it. If it does not find one, it will attempt to create
+a new branch or bookmark.
 
 When "arc work" creates a branch or bookmark, it will use **--start** as the
 branchpoint if it is provided. Otherwise, the current working copy state will
 serve as the starting point.
 EOHELP
       );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Begin or resume work.'))
       ->addExample(pht('**work** [--start __start__] __symbol__'))
       ->setHelp($help);
   }
 
   public function runWorkflow() {
     $api = $this->getRepositoryAPI();
 
     $work_engine = $api->getWorkEngine();
     if (!$work_engine) {
       throw new PhutilArgumentUsageException(
         pht(
           '"arc work" must be run in a Git or Mercurial working copy.'));
     }
 
     $argv = $this->getArgument('symbol');
     if (count($argv) === 0) {
       throw new PhutilArgumentUsageException(
         pht(
           'Provide a branch, bookmark, task, or revision name to begin '.
           'or resume work on.'));
     } else if (count($argv) === 1) {
       $symbol_argument = $argv[0];
       if (!strlen($symbol_argument)) {
         throw new PhutilArgumentUsageException(
           pht(
             'Provide a nonempty symbol to begin or resume work on.'));
       }
     } else {
       throw new PhutilArgumentUsageException(
         pht(
           'Too many arguments: provide exactly one argument.'));
     }
 
     $start_argument = $this->getArgument('start');
 
     $work_engine
       ->setViewer($this->getViewer())
       ->setWorkflow($this)
       ->setLogEngine($this->getLogEngine())
       ->setSymbolArgument($symbol_argument)
       ->setStartArgument($start_argument)
       ->execute();
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistWorkflow.php b/src/workflow/ArcanistWorkflow.php
index 85b917b7..a93238d7 100644
--- a/src/workflow/ArcanistWorkflow.php
+++ b/src/workflow/ArcanistWorkflow.php
@@ -1,2470 +1,2468 @@
 <?php
 
 /**
  * Implements a runnable command, like "arc diff" or "arc help".
  *
  * = Managing Conduit =
  *
  * Workflows have the builtin ability to open a Conduit connection to a
  * Phabricator installation, so methods can be invoked over the API. Workflows
  * may either not need this (e.g., "help"), or may need a Conduit but not
  * authentication (e.g., calling only public APIs), or may need a Conduit and
  * authentication (e.g., "arc diff").
  *
  * To specify that you need an //unauthenticated// conduit, override
  * @{method:requiresConduit} to return ##true##. To specify that you need an
  * //authenticated// conduit, override @{method:requiresAuthentication} to
  * return ##true##. You can also manually invoke @{method:establishConduit}
  * and/or @{method:authenticateConduit} later in a workflow to upgrade it.
  * Once a conduit is open, you can access the client by calling
  * @{method:getConduit}, which allows you to invoke methods. You can get
  * verified information about the user identity by calling @{method:getUserPHID}
  * or @{method:getUserName} after authentication occurs.
  *
  * = Scratch Files =
  *
  * Arcanist workflows can read and write 'scratch files', which are temporary
  * files stored in the project that persist across commands. They can be useful
  * if you want to save some state, or keep a copy of a long message the user
  * entered if something goes wrong.
  *
  *
  * @task  conduit   Conduit
  * @task  scratch   Scratch Files
  * @task  phabrep   Phabricator Repositories
  */
 abstract class ArcanistWorkflow extends Phobject {
 
   const COMMIT_DISABLE = 0;
   const COMMIT_ALLOW = 1;
   const COMMIT_ENABLE = 2;
 
   private $commitMode = self::COMMIT_DISABLE;
 
   private $conduit;
   private $conduitURI;
   private $conduitCredentials;
   private $conduitAuthenticated;
   private $conduitTimeout;
 
   private $userPHID;
   private $userName;
   private $repositoryAPI;
   private $configurationManager;
   private $arguments = array();
   private $command;
 
   private $stashed;
   private $shouldAmend;
 
   private $projectInfo;
   private $repositoryInfo;
   private $repositoryReasons;
   private $repositoryRef;
 
   private $arcanistConfiguration;
   private $parentWorkflow;
   private $workingDirectory;
   private $repositoryVersion;
 
   private $changeCache = array();
   private $conduitEngine;
 
   private $toolset;
   private $runtime;
   private $configurationEngine;
   private $configurationSourceList;
 
   private $promptMap;
 
   final public function setToolset(ArcanistToolset $toolset) {
     $this->toolset = $toolset;
     return $this;
   }
 
   final public function getToolset() {
     return $this->toolset;
   }
 
   final public function setRuntime(ArcanistRuntime $runtime) {
     $this->runtime = $runtime;
     return $this;
   }
 
   final public function getRuntime() {
     return $this->runtime;
   }
 
   final public function setConfigurationEngine(
     ArcanistConfigurationEngine $engine) {
     $this->configurationEngine = $engine;
     return $this;
   }
 
   final public function getConfigurationEngine() {
     return $this->configurationEngine;
   }
 
   final public function setConfigurationSourceList(
     ArcanistConfigurationSourceList $list) {
     $this->configurationSourceList = $list;
     return $this;
   }
 
   final public function getConfigurationSourceList() {
     return $this->configurationSourceList;
   }
 
   public function newPhutilWorkflow() {
     $arguments = $this->getWorkflowArguments();
     assert_instances_of($arguments, 'ArcanistWorkflowArgument');
 
     $specs = mpull($arguments, 'getPhutilSpecification');
 
     $phutil_workflow = id(new ArcanistPhutilWorkflow())
       ->setName($this->getWorkflowName())
       ->setWorkflow($this)
       ->setArguments($specs);
 
     $information = $this->getWorkflowInformation();
 
     if ($information !== null) {
       if (!($information instanceof ArcanistWorkflowInformation)) {
         throw new Exception(
           pht(
             'Expected workflow ("%s", of class "%s") to return an '.
             '"ArcanistWorkflowInformation" object from call to '.
             '"getWorkflowInformation()", got %s.',
             $this->getWorkflowName(),
             get_class($this),
             phutil_describe_type($information)));
       }
     }
 
     if ($information) {
       $synopsis = $information->getSynopsis();
       if ($synopsis !== null) {
         $phutil_workflow->setSynopsis($synopsis);
       }
 
       $examples = $information->getExamples();
       if ($examples) {
         $examples = implode("\n", $examples);
         $phutil_workflow->setExamples($examples);
       }
 
       $help = $information->getHelp();
       if ($help !== null) {
         // Unwrap linebreaks in the help text so we don't get weird formatting.
         $help = preg_replace("/(?<=\S)\n(?=\S)/", ' ', $help);
 
         $phutil_workflow->setHelp($help);
       }
     }
 
     return $phutil_workflow;
   }
 
   final public function newLegacyPhutilWorkflow() {
     $phutil_workflow = id(new ArcanistPhutilWorkflow())
       ->setName($this->getWorkflowName());
 
     $arguments = $this->getArguments();
 
     $specs = array();
     foreach ($arguments as $key => $argument) {
       if ($key == '*') {
         $key = $argument;
         $argument = array(
           'wildcard' => true,
         );
       }
 
       unset($argument['paramtype']);
       unset($argument['supports']);
       unset($argument['nosupport']);
       unset($argument['passthru']);
       unset($argument['conflict']);
 
       $spec = array(
         'name' => $key,
       ) + $argument;
 
       $specs[] = $spec;
     }
 
     $phutil_workflow->setArguments($specs);
 
     $synopses = $this->getCommandSynopses();
     $phutil_workflow->setSynopsis($synopses);
 
     $help = $this->getCommandHelp();
     if (strlen($help)) {
       $phutil_workflow->setHelp($help);
     }
 
     return $phutil_workflow;
   }
 
   final protected function newWorkflowArgument($key) {
     return id(new ArcanistWorkflowArgument())
       ->setKey($key);
   }
 
   final protected function newWorkflowInformation() {
     return new ArcanistWorkflowInformation();
   }
 
   final public function executeWorkflow(PhutilArgumentParser $args) {
     $runtime = $this->getRuntime();
 
     $this->arguments = $args;
     $caught = null;
 
     $runtime->pushWorkflow($this);
 
     try {
       $err = $this->runWorkflow($args);
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     try {
       $this->runWorkflowCleanup();
     } catch (Exception $ex) {
       phlog($ex);
     }
 
     $runtime->popWorkflow();
 
     if ($caught) {
       throw $caught;
     }
 
     return $err;
   }
 
   final public function getLogEngine() {
     return $this->getRuntime()->getLogEngine();
   }
 
   protected function runWorkflowCleanup() {
     // TOOLSETS: Do we need this?
     return;
   }
 
   public function __construct() {}
 
   public function run() {
     throw new PhutilMethodNotImplementedException();
   }
 
   /**
    * 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.
    */
   public function getCommandSynopses() {
     return array();
   }
 
   /**
    * Return console formatted string with command help printed in `arc help`.
    *
    * @return string  10-space indented help to use the command.
    */
   public function getCommandHelp() {
     return null;
   }
 
   public function supportsToolset(ArcanistToolset $toolset) {
     return false;
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Set the URI which the workflow will open a conduit connection to when
    * @{method:establishConduit} is called. Arcanist makes an effort to set
    * this by default for all workflows (by reading ##.arcconfig## and/or the
    * value of ##--conduit-uri##) even if they don't need Conduit, so a workflow
    * can generally upgrade into a conduit workflow later by just calling
    * @{method:establishConduit}.
    *
    * You generally should not need to call this method unless you are
    * specifically overriding the default URI. It is normally sufficient to
    * just invoke @{method:establishConduit}.
    *
    * NOTE: You can not call this after a conduit has been established.
    *
    * @param string  The URI to open a conduit to when @{method:establishConduit}
    *                is called.
    * @return this
    * @task conduit
    */
   final public function setConduitURI($conduit_uri) {
     if ($this->conduit) {
       throw new Exception(
         pht(
           'You can not change the Conduit URI after a '.
           'conduit is already open.'));
     }
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   /**
    * Returns the URI the conduit connection within the workflow uses.
    *
    * @return string
    * @task conduit
    */
   final public function getConduitURI() {
     return $this->conduitURI;
   }
 
   /**
    * Open a conduit channel to the server which was previously configured by
    * calling @{method:setConduitURI}. Arcanist will do this automatically if
    * the workflow returns ##true## from @{method:requiresConduit}, or you can
    * later upgrade a workflow and build a conduit by invoking it manually.
    *
    * You must establish a conduit before you can make conduit calls.
    *
    * NOTE: You must call @{method:setConduitURI} before you can call this
    * method.
    *
    * @return this
    * @task conduit
    */
   final public function establishConduit() {
     if ($this->conduit) {
       return $this;
     }
 
     if (!$this->conduitURI) {
       throw new Exception(
         pht(
           'You must specify a Conduit URI with %s before you can '.
           'establish a conduit.',
           'setConduitURI()'));
     }
 
     $this->conduit = new ConduitClient($this->conduitURI);
 
     if ($this->conduitTimeout) {
       $this->conduit->setTimeout($this->conduitTimeout);
     }
 
     return $this;
   }
 
   final public function getConfigFromAnySource($key) {
     $source_list = $this->getConfigurationSourceList();
     if ($source_list) {
       $value_list = $source_list->getStorageValueList($key);
       if ($value_list) {
         return last($value_list)->getValue();
       }
 
       return null;
     }
 
     return $this->configurationManager->getConfigFromAnySource($key);
   }
 
 
   /**
    * Set credentials which will be used to authenticate against Conduit. These
    * credentials can then be used to establish an authenticated connection to
    * conduit by calling @{method:authenticateConduit}. Arcanist sets some
    * defaults for all workflows regardless of whether or not they return true
    * from @{method:requireAuthentication}, based on the ##~/.arcrc## and
    * ##.arcconf## files if they are present. Thus, you can generally upgrade a
    * workflow which does not require authentication into an authenticated
    * workflow by later invoking @{method:requireAuthentication}. You should not
    * normally need to call this method unless you are specifically overriding
    * the defaults.
    *
    * NOTE: You can not call this method after calling
    * @{method:authenticateConduit}.
    *
    * @param dict  A credential dictionary, see @{method:authenticateConduit}.
    * @return this
    * @task conduit
    */
   final public function setConduitCredentials(array $credentials) {
     if ($this->isConduitAuthenticated()) {
       throw new Exception(
         pht('You may not set new credentials after authenticating conduit.'));
     }
 
     $this->conduitCredentials = $credentials;
     return $this;
   }
 
 
   /**
    * 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 6;
   }
 
 
   /**
    * Open and authenticate a conduit connection to a Phabricator server using
    * provided credentials. Normally, Arcanist does this for you automatically
    * when you return true from @{method:requiresAuthentication}, but you can
    * also upgrade an existing workflow to one with an authenticated conduit
    * by invoking this method manually.
    *
    * You must authenticate the conduit before you can make authenticated conduit
    * calls (almost all calls require authentication).
    *
    * This method uses credentials provided via @{method:setConduitCredentials}
    * to authenticate to the server:
    *
    *    - ##user## (required) The username to authenticate with.
    *    - ##certificate## (required) The Conduit certificate to use.
    *    - ##description## (optional) Description of the invoking command.
    *
    * Successful authentication allows you to call @{method:getUserPHID} and
    * @{method:getUserName}, as well as use the client you access with
    * @{method:getConduit} to make authenticated calls.
    *
    * NOTE: You must call @{method:setConduitURI} and
    * @{method:setConduitCredentials} before you invoke this method.
    *
    * @return this
    * @task conduit
    */
   final public function authenticateConduit() {
     if ($this->isConduitAuthenticated()) {
       return $this;
     }
 
     $this->establishConduit();
     $credentials = $this->conduitCredentials;
 
     try {
       if (!$credentials) {
         throw new Exception(
           pht(
             'Set conduit credentials with %s before authenticating conduit!',
             'setConduitCredentials()'));
       }
 
       // If we have `token`, this server supports the simpler, new-style
       // token-based authentication. Use that instead of all the certificate
       // stuff.
       $token = idx($credentials, 'token');
       if (strlen($token)) {
         $conduit = $this->getConduit();
 
         $conduit->setConduitToken($token);
 
         try {
           $result = $this->getConduit()->callMethodSynchronous(
             'user.whoami',
             array());
 
           $this->userName = $result['userName'];
           $this->userPHID = $result['phid'];
 
           $this->conduitAuthenticated = true;
 
           return $this;
         } catch (Exception $ex) {
           $conduit->setConduitToken(null);
           throw $ex;
         }
       }
 
       if (empty($credentials['user'])) {
         throw new ConduitClientException(
           'ERR-INVALID-USER',
           pht('Empty user in credentials.'));
       }
       if (empty($credentials['certificate'])) {
         throw new ConduitClientException(
           'ERR-NO-CERTIFICATE',
           pht('Empty certificate in credentials.'));
       }
 
       $description = idx($credentials, 'description', '');
       $user        = $credentials['user'];
       $certificate = $credentials['certificate'];
 
       $connection = $this->getConduit()->callMethodSynchronous(
         'conduit.connect',
         array(
           'client'              => 'arc',
           'clientVersion'       => $this->getConduitVersion(),
           'clientDescription'   => php_uname('n').':'.$description,
           'user'                => $user,
           'certificate'         => $certificate,
           'host'                => $this->conduitURI,
         ));
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-NO-CERTIFICATE' ||
           $ex->getErrorCode() == 'ERR-INVALID-USER' ||
           $ex->getErrorCode() == 'ERR-INVALID-AUTH') {
         $conduit_uri = $this->conduitURI;
         $message = phutil_console_format(
           "\n%s\n\n    %s\n\n%s\n%s",
-          pht('YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR'),
+          pht('YOU NEED TO __INSTALL A CERTIFICATE__ TO LOG IN'),
           pht('To do this, run: **%s**', 'arc install-certificate'),
           pht("The server '%s' rejected your request:", $conduit_uri),
           $ex->getMessage());
         throw new ArcanistUsageException($message);
       } else if ($ex->getErrorCode() == 'NEW-ARC-VERSION') {
 
         // Cleverly disguise this as being AWESOME!!!
 
         echo phutil_console_format("**%s**\n\n", pht('New Version Available!'));
         echo phutil_console_wrap($ex->getMessage());
         echo "\n\n";
         echo pht('In most cases, arc can be upgraded automatically.')."\n";
 
         $ok = phutil_console_confirm(
           pht('Upgrade arc now?'),
           $default_no = false);
         if (!$ok) {
           throw $ex;
         }
 
         $root = dirname(phutil_get_library_root('arcanist'));
 
         chdir($root);
         $err = phutil_passthru('%s upgrade', $root.'/bin/arc');
         if (!$err) {
           echo "\n".pht('Try running your arc command again.')."\n";
         }
         exit(1);
       } else {
         throw $ex;
       }
     }
 
     $this->userName = $user;
     $this->userPHID = $connection['userPHID'];
 
     $this->conduitAuthenticated = true;
 
     return $this;
   }
 
   /**
    * @return bool True if conduit is authenticated, false otherwise.
    * @task conduit
    */
   final protected function isConduitAuthenticated() {
     return (bool)$this->conduitAuthenticated;
   }
 
 
   /**
    * Override this to return true if your workflow requires a conduit channel.
    * Arc will build the channel for you before your workflow executes. This
    * implies that you only need an unauthenticated channel; if you need
    * authentication, override @{method:requiresAuthentication}.
    *
    * @return bool True if arc should build a conduit channel before running
    *              the workflow.
    * @task conduit
    */
   public function requiresConduit() {
     return false;
   }
 
 
   /**
    * Override this to return true if your workflow requires an authenticated
    * conduit channel. This implies that it requires a conduit. Arc will build
    * and authenticate the channel for you before the workflow executes.
    *
    * @return bool True if arc should build an authenticated conduit channel
    *              before running the workflow.
    * @task conduit
    */
   public function requiresAuthentication() {
     return false;
   }
 
 
   /**
    * Returns the PHID for the user once they've authenticated via Conduit.
    *
    * @return phid Authenticated user PHID.
    * @task conduit
    */
   final public function getUserPHID() {
     if (!$this->userPHID) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires authentication, override ".
           "%s to return true.",
           $workflow,
           'requiresAuthentication()'));
     }
     return $this->userPHID;
   }
 
   /**
    * Return the username for the user once they've authenticated via Conduit.
    *
    * @return string Authenticated username.
    * @task conduit
    */
   final public function getUserName() {
     return $this->userName;
   }
 
 
   /**
    * Get the established @{class@libphutil:ConduitClient} in order to make
    * Conduit method calls. Before the client is available it must be connected,
    * either implicitly by making @{method:requireConduit} or
    * @{method:requireAuthentication} return true, or explicitly by calling
    * @{method:establishConduit} or @{method:authenticateConduit}.
    *
    * @return @{class@libphutil:ConduitClient} Live conduit client.
    * @task conduit
    */
   final public function getConduit() {
     if (!$this->conduit) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Conduit, override ".
           "%s to return true.",
           $workflow,
           'requiresConduit()'));
     }
     return $this->conduit;
   }
 
 
   final public function setArcanistConfiguration(
     ArcanistConfiguration $arcanist_configuration) {
 
     $this->arcanistConfiguration = $arcanist_configuration;
     return $this;
   }
 
   final public function getArcanistConfiguration() {
     return $this->arcanistConfiguration;
   }
 
   final public function setConfigurationManager(
     ArcanistConfigurationManager $arcanist_configuration_manager) {
 
     $this->configurationManager = $arcanist_configuration_manager;
     return $this;
   }
 
   final public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
   public function desiresWorkingCopy() {
     return false;
   }
 
   public function requiresRepositoryAPI() {
     return false;
   }
 
   public function desiresRepositoryAPI() {
     return false;
   }
 
   final public function setCommand($command) {
     $this->command = $command;
     return $this;
   }
 
   final public function getCommand() {
     return $this->command;
   }
 
   public function getArguments() {
     return array();
   }
 
   final public function setWorkingDirectory($working_directory) {
     $this->workingDirectory = $working_directory;
     return $this;
   }
 
   final public function getWorkingDirectory() {
     return $this->workingDirectory;
   }
 
   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->setConduitEngine($this->getConduitEngine());
     $workflow->setCommand($command);
     $workflow->setConfigurationManager($this->getConfigurationManager());
 
     if ($this->repositoryAPI) {
       $workflow->setRepositoryAPI($this->repositoryAPI);
     }
 
     if ($this->userPHID) {
       $workflow->userPHID = $this->getUserPHID();
       $workflow->userName = $this->getUserName();
     }
 
     if ($this->conduit) {
       $workflow->conduit = $this->conduit;
       $workflow->setConduitCredentials($this->conduitCredentials);
       $workflow->conduitAuthenticated = $this->conduitAuthenticated;
     }
 
     $workflow->setArcanistConfiguration($arc_config);
 
     $workflow->parseArguments(array_values($argv));
 
     return $workflow;
   }
 
   final public function getArgument($key, $default = null) {
     // TOOLSETS: Remove this legacy code.
     if (is_array($this->arguments)) {
       return idx($this->arguments, $key, $default);
     }
 
     return $this->arguments->getArg($key);
   }
 
   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) {
     $spec = $this->getCompleteArgumentSpecification();
 
     $dict = array();
 
     $more_key = null;
     if (!empty($spec['*'])) {
       $more_key = $spec['*'];
       unset($spec['*']);
       $dict[$more_key] = array();
     }
 
     $short_to_long_map = array();
     foreach ($spec as $long => $options) {
       if (!empty($options['short'])) {
         $short_to_long_map[$options['short']] = $long;
       }
     }
 
     foreach ($spec as $long => $options) {
       if (!empty($options['repeat'])) {
         $dict[$long] = array();
       }
     }
 
     $more = array();
     $size = count($args);
     for ($ii = 0; $ii < $size; $ii++) {
       $arg = $args[$ii];
       $arg_name = null;
       $arg_key = null;
       if ($arg == '--') {
         $more = array_merge(
           $more,
           array_slice($args, $ii + 1));
         break;
       } else if (!strncmp($arg, '--', 2)) {
         $arg_key = substr($arg, 2);
         $parts = explode('=', $arg_key, 2);
         if (count($parts) == 2) {
           list($arg_key, $val) = $parts;
 
           array_splice($args, $ii, 1, array('--'.$arg_key, $val));
           $size++;
         }
 
         if (!array_key_exists($arg_key, $spec)) {
           $corrected = PhutilArgumentSpellingCorrector::newFlagCorrector()
             ->correctSpelling($arg_key, array_keys($spec));
           if (count($corrected) == 1) {
             PhutilConsole::getConsole()->writeErr(
               pht(
                 "(Assuming '%s' is the British spelling of '%s'.)",
                 '--'.$arg_key,
                 '--'.head($corrected))."\n");
             $arg_key = head($corrected);
           } else {
             throw new ArcanistUsageException(
               pht(
                 "Unknown argument '%s'. Try '%s'.",
                 $arg_key,
                 'arc help'));
           }
         }
       } else if (!strncmp($arg, '-', 1)) {
         $arg_key = substr($arg, 1);
         if (empty($short_to_long_map[$arg_key])) {
           throw new ArcanistUsageException(
             pht(
               "Unknown argument '%s'. Try '%s'.",
               $arg_key,
               'arc help'));
         }
         $arg_key = $short_to_long_map[$arg_key];
       } else {
         $more[] = $arg;
         continue;
       }
 
       $options = $spec[$arg_key];
       if (empty($options['param'])) {
         $dict[$arg_key] = true;
       } else {
         if ($ii == $size - 1) {
           throw new ArcanistUsageException(
             pht(
               "Option '%s' requires a parameter.",
               $arg));
         }
         if (!empty($options['repeat'])) {
           $dict[$arg_key][] = $args[$ii + 1];
         } else {
           $dict[$arg_key] = $args[$ii + 1];
         }
         $ii++;
       }
     }
 
     if ($more) {
       if ($more_key) {
         $dict[$more_key] = $more;
       } else {
         $example = reset($more);
         throw new ArcanistUsageException(
           pht(
             "Unrecognized argument '%s'. Try '%s'.",
             $example,
             'arc help'));
       }
     }
 
     foreach ($dict as $key => $value) {
       if (empty($spec[$key]['conflicts'])) {
         continue;
       }
       foreach ($spec[$key]['conflicts'] as $conflict => $more) {
         if (isset($dict[$conflict])) {
           if ($more) {
             $more = ': '.$more;
           } else {
             $more = '.';
           }
           // TODO: We'll always display these as long-form, when the user might
           // have typed them as short form.
           throw new ArcanistUsageException(
             pht(
               "Arguments '%s' and '%s' are mutually exclusive",
               "--{$key}",
               "--{$conflict}").$more);
         }
       }
     }
 
     $this->arguments = $dict;
 
     $this->didParseArguments();
 
     return $this;
   }
 
   protected function didParseArguments() {
     // Override this to customize workflow argument behavior.
   }
 
   final public function getWorkingCopy() {
     $configuration_engine = $this->getConfigurationEngine();
 
     // TOOLSETS: Remove this once all workflows are toolset workflows.
     if (!$configuration_engine) {
       throw new Exception(
         pht(
           'This workflow has not yet been updated to Toolsets and can '.
           'not retrieve a modern WorkingCopy object. Use '.
           '"getWorkingCopyIdentity()" to retrieve a previous-generation '.
           'object.'));
     }
 
     return $configuration_engine->getWorkingCopy();
   }
 
 
   final public function getWorkingCopyIdentity() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       $working_copy = $configuration_engine->getWorkingCopy();
       $working_path = $working_copy->getWorkingDirectory();
 
       return ArcanistWorkingCopyIdentity::newFromPath($working_path);
     }
 
     $working_copy = $this->getConfigurationManager()->getWorkingCopyIdentity();
     if (!$working_copy) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a working copy, override ".
           "%s to return true.",
           $workflow,
           'requiresWorkingCopy()'));
     }
     return $working_copy;
   }
 
   final public function setRepositoryAPI($api) {
     $this->repositoryAPI = $api;
     return $this;
   }
 
   final public function hasRepositoryAPI() {
     try {
       return (bool)$this->getRepositoryAPI();
     } catch (Exception $ex) {
       return false;
     }
   }
 
   final public function getRepositoryAPI() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       $working_copy = $configuration_engine->getWorkingCopy();
       return $working_copy->getRepositoryAPI();
     }
 
     if (!$this->repositoryAPI) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Repository API, override ".
           "%s to return true.",
           $workflow,
           'requiresRepositoryAPI()'));
     }
     return $this->repositoryAPI;
   }
 
   final protected function shouldRequireCleanUntrackedFiles() {
     return empty($this->arguments['allow-untracked']);
   }
 
   final public function setCommitMode($mode) {
     $this->commitMode = $mode;
     return $this;
   }
 
   final public function finalizeWorkingCopy() {
     if ($this->stashed) {
       $api = $this->getRepositoryAPI();
       $api->unstashChanges();
       echo pht('Restored stashed changes to the working directory.')."\n";
     }
   }
 
   final public function requireCleanWorkingCopy() {
     $api = $this->getRepositoryAPI();
 
     $must_commit = array();
 
     $working_copy_desc = phutil_console_format(
       "  %s: __%s__\n\n",
       pht('Working copy'),
       $api->getPath());
 
     // NOTE: this is a subversion-only concept.
     $incomplete = $api->getIncompleteChanges();
     if ($incomplete) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n\n%s",
           pht(
             "You have incompletely checked out directories in this working ".
             "copy. Fix them before proceeding.'"),
           $working_copy_desc,
           pht('Incomplete directories in working copy:'),
           implode("\n    ", $incomplete),
           pht(
             "You can fix these paths by running '%s' on them.",
             'svn update')));
     }
 
     $conflicts = $api->getMergeConflicts();
     if ($conflicts) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s",
           pht(
             'You have merge conflicts in this working copy. Resolve merge '.
             'conflicts before proceeding.'),
           $working_copy_desc,
           pht('Conflicts in working copy:'),
           implode("\n    ", $conflicts)));
     }
 
     $missing = $api->getMissingChanges();
     if ($missing) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n",
           pht(
             'You have missing files in this working copy. Revert or formally '.
             'remove them (with `%s`) before proceeding.',
             'svn rm'),
           $working_copy_desc,
           pht('Missing files in working copy:'),
           implode("\n    ", $missing)));
     }
 
     $externals = $api->getDirtyExternalChanges();
 
     // TODO: This state can exist in Subversion, but it is currently handled
     // elsewhere. It should probably be handled here, eventually.
     if ($api instanceof ArcanistSubversionAPI) {
       $externals = array();
     }
 
     if ($externals) {
       $message = pht(
         '%s submodule(s) have uncommitted or untracked changes:',
         new PhutilNumber(count($externals)));
 
       $prompt = pht(
         'Ignore the changes to these %s submodule(s) and continue?',
         new PhutilNumber(count($externals)));
 
       $list = id(new PhutilConsoleList())
         ->setWrap(false)
         ->addItems($externals);
 
       id(new PhutilConsoleBlock())
         ->addParagraph($message)
         ->addList($list)
         ->draw();
 
       $ok = phutil_console_confirm($prompt, $default_no = false);
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     $uncommitted = $api->getUncommittedChanges();
     $unstaged = $api->getUnstagedChanges();
 
     // We already dealt with externals.
     $unstaged = array_diff($unstaged, $externals);
 
     // We only want files which are purely uncommitted.
     $uncommitted = array_diff($uncommitted, $unstaged);
     $uncommitted = array_diff($uncommitted, $externals);
 
     $untracked = $api->getUntrackedChanges();
     if (!$this->shouldRequireCleanUntrackedFiles()) {
       $untracked = array();
     }
 
     if ($untracked) {
       echo sprintf(
         "%s\n\n%s",
         pht('You have untracked files in this working copy.'),
         $working_copy_desc);
 
       if ($api instanceof ArcanistGitAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.git/info/exclude');
       } else if ($api instanceof ArcanistSubversionAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           'svn:ignore');
       } else if ($api instanceof ArcanistMercurialAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.hgignore');
       }
 
       $untracked_list = "    ".implode("\n    ", $untracked);
       echo sprintf(
         "  %s\n  %s\n%s",
         pht('Untracked changes in working copy:'),
         $hint,
         $untracked_list);
 
       $prompt = pht(
         'Ignore these %s untracked file(s) and continue?',
         phutil_count($untracked));
 
       if (!phutil_console_confirm($prompt)) {
         throw new ArcanistUserAbortException();
       }
     }
 
 
     $should_commit = false;
     if ($unstaged || $uncommitted) {
 
       // NOTE: We're running this because it builds a cache and can take a
       // perceptible amount of time to arrive at an answer, but we don't want
       // to pause in the middle of printing the output below.
       $this->getShouldAmend();
 
       echo sprintf(
         "%s\n\n%s",
         pht('You have uncommitted changes in this working copy.'),
         $working_copy_desc);
 
       $lists = array();
 
       if ($unstaged) {
         $unstaged_list = "    ".implode("\n    ", $unstaged);
         $lists[] = sprintf(
           "  %s\n%s",
           pht('Unstaged changes in working copy:'),
           $unstaged_list);
       }
 
       if ($uncommitted) {
         $uncommitted_list = "    ".implode("\n    ", $uncommitted);
         $lists[] = sprintf(
           "%s\n%s",
           pht('Uncommitted changes in working copy:'),
           $uncommitted_list);
       }
 
       echo implode("\n\n", $lists)."\n";
 
       $all_uncommitted = array_merge($unstaged, $uncommitted);
       if ($this->askForAdd($all_uncommitted)) {
         if ($unstaged) {
           $api->addToCommit($unstaged);
         }
         $should_commit = true;
       } else {
         $permit_autostash = $this->getConfigFromAnySource('arc.autostash');
         if ($permit_autostash && $api->canStashChanges()) {
            echo pht(
             'Stashing uncommitted changes. (You can restore them with `%s`).',
             'git stash pop')."\n";
           $api->stashChanges();
           $this->stashed = true;
         } else {
           throw new ArcanistUsageException(
             pht(
               'You can not continue with uncommitted changes. '.
               'Commit or discard them before proceeding.'));
         }
       }
     }
 
     if ($should_commit) {
       if ($this->getShouldAmend()) {
         $commit = head($api->getLocalCommitInformation());
         $api->amendCommit($commit['message']);
       } else if ($api->supportsLocalCommits()) {
         $template = sprintf(
           "\n\n# %s\n#\n# %s\n#\n",
           pht('Enter a commit message.'),
           pht('Changes:'));
 
         $paths = array_merge($uncommitted, $unstaged);
         $paths = array_unique($paths);
         sort($paths);
 
         foreach ($paths as $path) {
           $template .= "#     ".$path."\n";
         }
 
         $commit_message = $this->newInteractiveEditor($template)
           ->setName(pht('commit-message'))
           ->setTaskMessage(pht(
             'Supply commit message for uncommitted changes, then save and '.
             'exit.'))
           ->editInteractively();
 
         if ($commit_message === $template) {
           throw new ArcanistUsageException(
             pht('You must provide a commit message.'));
         }
 
         $commit_message = ArcanistCommentRemover::removeComments(
           $commit_message);
 
         if (!strlen($commit_message)) {
           throw new ArcanistUsageException(
             pht('You must provide a nonempty commit message.'));
         }
 
         $api->doCommit($commit_message);
       }
     }
   }
 
   private function getShouldAmend() {
     if ($this->shouldAmend === null) {
       $this->shouldAmend = $this->calculateShouldAmend();
     }
     return $this->shouldAmend;
   }
 
   private function calculateShouldAmend() {
     $api = $this->getRepositoryAPI();
 
     if ($this->isHistoryImmutable() || !$api->supportsAmend()) {
       return false;
     }
 
     $commits = $api->getLocalCommitInformation();
     if (!$commits) {
       return false;
     }
 
     $commit = reset($commits);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
       $commit['message']);
 
     if ($message->getGitSVNBaseRevision()) {
       return false;
     }
 
     if ($api->getAuthor() != $commit['author']) {
       return false;
     }
 
     if ($message->getRevisionID() && $this->getArgument('create')) {
       return false;
     }
 
     // TODO: Check commits since tracking branch. If empty then return false.
 
     // Don't amend the current commit if it has already been published.
     $repository = $this->loadProjectRepository();
     if ($repository) {
       $repo_id = $repository['id'];
       $commit_hash = $commit['commit'];
       $callsign =  idx($repository, 'callsign');
       if ($callsign) {
         // The server might be too old to support the new style commit names,
         // so prefer the old way
         $commit_name = "r{$callsign}{$commit_hash}";
       } else {
         $commit_name = "R{$repo_id}:{$commit_hash}";
       }
 
       $result = $this->getConduit()->callMethodSynchronous(
         'diffusion.querycommits',
         array('names' => array($commit_name)));
       $known_commit = idx($result['identifierMap'], $commit_name);
       if ($known_commit) {
         return false;
       }
     }
 
     if (!$message->getRevisionID()) {
       return true;
     }
 
     $in_working_copy = $api->loadWorkingCopyDifferentialRevisions(
       $this->getConduit(),
       array(
         'authors' => array($this->getUserPHID()),
         'status' => 'status-open',
       ));
     if ($in_working_copy) {
       return true;
     }
 
     return false;
   }
 
   private function askForAdd(array $files) {
     if ($this->commitMode == self::COMMIT_DISABLE) {
       return false;
     }
     if ($this->commitMode == self::COMMIT_ENABLE) {
       return true;
     }
     $prompt = $this->getAskForAddPrompt($files);
     return phutil_console_confirm($prompt);
   }
 
   private function getAskForAddPrompt(array $files) {
     if ($this->getShouldAmend()) {
       $prompt = pht(
         'Do you want to amend these %s change(s) to the current commit?',
         phutil_count($files));
     } else {
       $prompt = pht(
         'Do you want to create a new commit with these %s change(s)?',
         phutil_count($files));
     }
     return $prompt;
   }
 
   final protected function loadDiffBundleFromConduit(
     ConduitClient $conduit,
     $diff_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'ids' => array($diff_id),
     ));
   }
 
   final protected function loadRevisionBundleFromConduit(
     ConduitClient $conduit,
     $revision_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'revisionIDs' => array($revision_id),
     ));
   }
 
   private function loadBundleFromConduit(
     ConduitClient $conduit,
     $params) {
 
     $future = $conduit->callMethod('differential.querydiffs', $params);
     $diff = head($future->resolve());
 
     if ($diff == null) {
       throw new Exception(
         phutil_console_wrap(
           pht("The diff or revision you specified is either invalid or you ".
           "don't have permission to view it."))
       );
     }
 
     $changes = array();
     foreach ($diff['changes'] as $changedict) {
       $changes[] = ArcanistDiffChange::newFromDictionary($changedict);
     }
     $bundle = ArcanistBundle::newFromChanges($changes);
     $bundle->setConduit($conduit);
     // since the conduit method has changes, assume that these fields
     // could be unset
     $bundle->setBaseRevision(idx($diff, 'sourceControlBaseRevision'));
     $bundle->setRevisionID(idx($diff, 'revisionID'));
     $bundle->setAuthorName(idx($diff, 'authorName'));
     $bundle->setAuthorEmail(idx($diff, 'authorEmail'));
     return $bundle;
   }
 
   /**
    * Return a list of lines changed by the current diff, or ##null## if the
    * change list is meaningless (for example, because the path is a directory
    * or binary file).
    *
    * @param string      Path within the repository.
    * @param string      Change selection mode (see ArcanistDiffHunk).
    * @return list|null  List of changed line numbers, or null to indicate that
    *                    the path is not a line-oriented text file.
    */
   final protected function getChangedLines($path, $mode) {
     $repository_api = $this->getRepositoryAPI();
     $full_path = $repository_api->getPath($path);
     if (is_dir($full_path)) {
       return null;
     }
 
     if (!file_exists($full_path)) {
       return null;
     }
 
     $change = $this->getChange($path);
 
     if ($change->getFileType() !== ArcanistDiffChangeType::FILE_TEXT) {
       return null;
     }
 
     $lines = $change->getChangedLines($mode);
     return array_keys($lines);
   }
 
   final protected function getChange($path) {
     $repository_api = $this->getRepositoryAPI();
 
     // TODO: Very gross
     $is_git = ($repository_api instanceof ArcanistGitAPI);
     $is_hg = ($repository_api instanceof ArcanistMercurialAPI);
     $is_svn = ($repository_api instanceof ArcanistSubversionAPI);
 
     if ($is_svn) {
       // NOTE: In SVN, we don't currently support a "get all local changes"
       // operation, so special case it.
       if (empty($this->changeCache[$path])) {
         $diff = $repository_api->getRawDiffText($path);
         $parser = $this->newDiffParser();
         $changes = $parser->parseDiff($diff);
         if (count($changes) != 1) {
           throw new Exception(pht('Expected exactly one change.'));
         }
         $this->changeCache[$path] = reset($changes);
       }
     } else if ($is_git || $is_hg) {
       if (empty($this->changeCache)) {
         $changes = $repository_api->getAllLocalChanges();
         foreach ($changes as $change) {
           $this->changeCache[$change->getCurrentPath()] = $change;
         }
       }
     } else {
       throw new Exception(pht('Missing VCS support.'));
     }
 
     if (empty($this->changeCache[$path])) {
       if ($is_git || $is_hg) {
         // This can legitimately occur under git/hg if you make a change,
         // "git/hg commit" it, and then revert the change in the working copy
         // and run "arc lint".
         $change = new ArcanistDiffChange();
         $change->setCurrentPath($path);
         return $change;
       } else {
         throw new Exception(
           pht(
             "Trying to get change for unchanged path '%s'!",
             $path));
       }
     }
 
     return $this->changeCache[$path];
   }
 
   final public function willRunWorkflow() {
     $spec = $this->getCompleteArgumentSpecification();
     foreach ($this->arguments as $arg => $value) {
       if (empty($spec[$arg])) {
         continue;
       }
       $options = $spec[$arg];
       if (!empty($options['supports'])) {
         $system_name = $this->getRepositoryAPI()->getSourceControlSystemName();
         if (!in_array($system_name, $options['supports'])) {
           $extended_info = null;
           if (!empty($options['nosupport'][$system_name])) {
             $extended_info = ' '.$options['nosupport'][$system_name];
           }
           throw new ArcanistUsageException(
             pht(
               "Option '%s' is not supported under %s.",
               "--{$arg}",
               $system_name).
             $extended_info);
         }
       }
     }
   }
 
   final protected function normalizeRevisionID($revision_id) {
     return preg_replace('/^D/i', '', $revision_id);
   }
 
   protected function shouldShellComplete() {
     return true;
   }
 
   protected function getShellCompletions(array $argv) {
     return array();
   }
 
   public function getSupportedRevisionControlSystems() {
     return array('git', 'hg', 'svn');
   }
 
   final protected function getPassthruArgumentsAsMap($command) {
     $map = array();
     foreach ($this->getCompleteArgumentSpecification() as $key => $spec) {
       if (!empty($spec['passthru'][$command])) {
         if (isset($this->arguments[$key])) {
           $map[$key] = $this->arguments[$key];
         }
       }
     }
     return $map;
   }
 
   final protected function getPassthruArgumentsAsArgv($command) {
     $spec = $this->getCompleteArgumentSpecification();
     $map = $this->getPassthruArgumentsAsMap($command);
     $argv = array();
     foreach ($map as $key => $value) {
       $argv[] = '--'.$key;
       if (!empty($spec[$key]['param'])) {
         $argv[] = $value;
       }
     }
     return $argv;
   }
 
   /**
    * Write a message to stderr so that '--json' flags or stdout which is meant
    * to be piped somewhere aren't disrupted.
    *
    * @param string  Message to write to stderr.
    * @return void
    */
   final protected function writeStatusMessage($msg) {
-    fwrite(STDERR, $msg);
+    PhutilSystem::writeStderr($msg);
   }
 
   final public function writeInfo($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:blue>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final public function writeWarn($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:yellow>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final public function writeOkay($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final protected function isHistoryImmutable() {
     $repository_api = $this->getRepositoryAPI();
 
     $config = $this->getConfigFromAnySource('history.immutable');
     if ($config !== null) {
       return $config;
     }
 
     return $repository_api->isHistoryDefaultImmutable();
   }
 
   /**
    * Workflows like 'lint' and 'unit' operate on a list of working copy paths.
    * The user can either specify the paths explicitly ("a.js b.php"), or by
    * specifying a revision ("--rev a3f10f1f") to select all paths modified
    * since that revision, or by omitting both and letting arc choose the
    * default relative revision.
    *
    * This method takes the user's selections and returns the paths that the
    * workflow should act upon.
    *
    * @param   list          List of explicitly provided paths.
    * @param   string|null   Revision name, if provided.
    * @param   mask          Mask of ArcanistRepositoryAPI flags to exclude.
    *                        Defaults to ArcanistRepositoryAPI::FLAG_UNTRACKED.
    * @return  list          List of paths the workflow should act on.
    */
   final protected function selectPathsForWorkflow(
     array $paths,
     $rev,
     $omit_mask = null) {
 
     if ($omit_mask === null) {
       $omit_mask = ArcanistRepositoryAPI::FLAG_UNTRACKED;
     }
 
     if ($paths) {
       $working_copy = $this->getWorkingCopyIdentity();
       foreach ($paths as $key => $path) {
         $full_path = Filesystem::resolvePath($path);
         if (!Filesystem::pathExists($full_path)) {
           throw new ArcanistUsageException(
             pht(
               "Path '%s' does not exist!",
               $path));
         }
         $relative_path = Filesystem::readablePath(
           $full_path,
           $working_copy->getProjectRoot());
         $paths[$key] = $relative_path;
       }
     } else {
       $repository_api = $this->getRepositoryAPI();
 
       if ($rev) {
         $this->parseBaseCommitArgument(array($rev));
       }
 
       $paths = $repository_api->getWorkingCopyStatus();
       foreach ($paths as $path => $flags) {
         if ($flags & $omit_mask) {
           unset($paths[$path]);
         }
       }
       $paths = array_keys($paths);
     }
 
     return array_values($paths);
   }
 
   final protected function renderRevisionList(array $revisions) {
     $list = array();
     foreach ($revisions as $revision) {
       $list[] = '     - D'.$revision['id'].': '.$revision['title']."\n";
     }
     return implode('', $list);
   }
 
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   final protected function readScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->readScratchFile($path);
   }
 
 
   /**
    * Try to read a scratch JSON file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return array Empty array for failure.
    * @task scratch
    */
   final protected function readScratchJSONFile($path) {
     $file = $this->readScratchFile($path);
     if (!$file) {
       return array();
     }
     return phutil_json_decode($file);
   }
 
 
   /**
    * Try to write a scratch file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  string Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchFile($path, $data) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->writeScratchFile($path, $data);
   }
 
 
   /**
    * Try to write a scratch JSON file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  array Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchJSONFile($path, array $data) {
     return $this->writeScratchFile($path, json_encode($data));
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   final protected function removeScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->removeScratchFile($path);
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   final protected function getReadableScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getReadableScratchFilePath($path);
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   final protected function getScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getScratchFilePath($path);
   }
 
   final protected function getRepositoryEncoding() {
     return nonempty(
       idx($this->loadProjectRepository(), 'encoding'),
       'UTF-8');
   }
 
   final protected function loadProjectRepository() {
     list($info, $reasons) = $this->loadRepositoryInformation();
     return coalesce($info, array());
   }
 
   final protected function newInteractiveEditor($text) {
     $editor = new PhutilInteractiveEditor($text);
 
     $preferred = $this->getConfigFromAnySource('editor');
     if ($preferred) {
       $editor->setPreferredEditor($preferred);
     }
 
     return $editor;
   }
 
   final protected function newDiffParser() {
     $parser = new ArcanistDiffParser();
     if ($this->repositoryAPI) {
       $parser->setRepositoryAPI($this->getRepositoryAPI());
     }
     $parser->setWriteDiffOnFailure(true);
     return $parser;
   }
 
   final protected function dispatchEvent($type, array $data) {
     $data += array(
       'workflow' => $this,
     );
 
     $event = new PhutilEvent($type, $data);
     PhutilEventEngine::dispatchEvent($event);
 
     return $event;
   }
 
   final public function parseBaseCommitArgument(array $argv) {
     if (!count($argv)) {
       return;
     }
 
     $api = $this->getRepositoryAPI();
     if (!$api->supportsCommitRanges()) {
       throw new ArcanistUsageException(
         pht('This version control system does not support commit ranges.'));
     }
 
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         pht(
           'Specify exactly one base commit. The end of the commit range is '.
           'always the working copy state.'));
     }
 
     $api->setBaseCommit(head($argv));
 
     return $this;
   }
 
   final protected function getRepositoryVersion() {
     if (!$this->repositoryVersion) {
       $api = $this->getRepositoryAPI();
       $commit = $api->getSourceControlBaseRevision();
       $versions = array('' => $commit);
       foreach ($api->getChangedFiles($commit) as $path => $mask) {
         $versions[$path] = (Filesystem::pathExists($path)
           ? md5_file($path)
           : '');
       }
       $this->repositoryVersion = md5(json_encode($versions));
     }
     return $this->repositoryVersion;
   }
 
 
 /* -(  Phabricator Repositories  )------------------------------------------- */
 
 
   /**
    * Get the PHID of the Phabricator repository this working copy corresponds
    * to. Returns `null` if no repository can be identified.
    *
    * @return phid|null  Repository PHID, or null if no repository can be
    *                    identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryPHID() {
     return idx($this->getRepositoryInformation(), 'phid');
   }
 
   /**
    * Get the name of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository name, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryName() {
     return idx($this->getRepositoryInformation(), 'name');
   }
 
 
   /**
    * Get the URI of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository URI, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryURI() {
     return idx($this->getRepositoryInformation(), 'uri');
   }
 
 
   final protected function getRepositoryStagingConfiguration() {
     return idx($this->getRepositoryInformation(), 'staging');
   }
 
 
   /**
    * Get human-readable reasoning explaining how `arc` evaluated which
    * Phabricator repository corresponds to this working copy. Used by
    * `arc which` to explain the process to users.
    *
    * @return list<string> Human-readable explanation of the repository
    *                      association process.
    *
    * @task phabrep
    */
   final protected function getRepositoryReasons() {
     $this->getRepositoryInformation();
     return $this->repositoryReasons;
   }
 
 
   /**
    * @task phabrep
    */
   private function getRepositoryInformation() {
     if ($this->repositoryInfo === null) {
       list($info, $reasons) = $this->loadRepositoryInformation();
       $this->repositoryInfo = nonempty($info, array());
       $this->repositoryReasons = $reasons;
     }
 
     return $this->repositoryInfo;
   }
 
 
   /**
    * @task phabrep
    */
   private function loadRepositoryInformation() {
     list($query, $reasons) = $this->getRepositoryQuery();
     if (!$query) {
       return array(null, $reasons);
     }
 
     try {
       $method = 'repository.query';
       $results = $this->getConduitEngine()
         ->newFuture($method, $query)
         ->resolve();
     } 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.');
+          'This software version on the server you are connecting to is out '.
+          'of date and does not have support for identifying repositories '.
+          'by callsign or URI. Update the server sofwware to enable these '.
+          'features.');
         return array(null, $reasons);
       }
       throw $ex;
     }
 
     $result = null;
     if (!$results) {
       $reasons[] = pht(
         'No repositories matched the query. Check that your configuration '.
         'is correct, or use "%s" to select a repository explicitly.',
         'repository.callsign');
     } else if (count($results) > 1) {
       $reasons[] = pht(
         'Multiple repostories (%s) matched the query. You can use the '.
         '"%s" configuration to select the one you want.',
         implode(', ', ipull($results, 'callsign')),
         'repository.callsign');
     } else {
       $result = head($results);
       $reasons[] = pht('Found a unique matching repository.');
     }
 
     return array($result, $reasons);
   }
 
 
   /**
    * @task phabrep
    */
   private function getRepositoryQuery() {
     $reasons = array();
 
     $callsign = $this->getConfigFromAnySource('repository.callsign');
     if ($callsign) {
       $query = array(
         'callsigns' => array($callsign),
       );
       $reasons[] = pht(
         'Configuration value "%s" is set to "%s".',
         'repository.callsign',
         $callsign);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'Configuration value "%s" is empty.',
         'repository.callsign');
     }
 
     $uuid = $this->getRepositoryAPI()->getRepositoryUUID();
     if ($uuid !== null) {
       $query = array(
         'uuids' => array($uuid),
       );
       $reasons[] = pht(
         'The UUID for this working copy is "%s".',
         $uuid);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'This repository has no VCS UUID (this is normal for git/hg).');
     }
 
     // TODO: Swap this for a RemoteRefQuery.
 
     $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->getWorkingCopyIdentity();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('lint.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arclint'))) {
         $engine_class = 'ArcanistConfigurationDrivenLintEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No lint engine is configured for this project. Create an '%s' ".
           "file, or configure an advanced engine with '%s' in '%s'.",
           '.arclint',
           'lint.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistLintEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured lint engine "%s" is not a subclass of "%s", but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
   /**
    * Build a new unit test engine for the current working copy.
    *
    * Optionally, you can pass an explicit engine class name to build an engine
    * of a particular class. Normally this is used to implement an `--engine`
    * flag from the CLI.
    *
    * @param string Optional explicit engine class name.
    * @return ArcanistUnitTestEngine Constructed engine.
    */
   protected function newUnitTestEngine($engine_class = null) {
     $working_copy = $this->getWorkingCopyIdentity();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('unit.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arcunit'))) {
         $engine_class = 'ArcanistConfigurationDrivenUnitTestEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No unit test engine is configured for this project. Create an ".
           "'%s' file, or configure an advanced engine with '%s' in '%s'.",
           '.arcunit',
           'unit.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistUnitTestEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured unit test engine "%s" is not a subclass of "%s", '.
           'but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
 
   protected function openURIsInBrowser(array $uris) {
     $browser = $this->getBrowserCommand();
 
     // The "browser" may actually be a list of arguments.
     if (!is_array($browser)) {
       $browser = array($browser);
     }
 
     foreach ($uris as $uri) {
       $err = phutil_passthru('%LR %R', $browser, $uri);
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             'Failed to open URI "%s" in browser ("%s"). '.
             'Check your "browser" config option.',
             $uri,
             implode(' ', $browser)));
       }
     }
   }
 
   private function getBrowserCommand() {
     $config = $this->getConfigFromAnySource('browser');
     if ($config) {
       return $config;
     }
 
     if (phutil_is_windows()) {
       // See T13504. We now use "bypass_shell", so "start" alone is no longer
       // a valid binary to invoke directly.
       return array(
         'cmd',
         '/c',
         'start',
       );
     }
 
     $candidates = array(
       'sensible-browser' => array('sensible-browser'),
       'xdg-open' => array('xdg-open'),
       'open' => array('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 => $argv) {
       if (Filesystem::binaryExists($cmd)) {
         return $argv;
       }
     }
 
     throw new ArcanistUsageException(
       pht(
-        "Unable to find a browser command to run. Set '%s' in your ".
-        "Arcanist config to specify a command to use.",
-        'browser'));
+        'Unable to find a browser command to run. Set "browser" in your '.
+        'configuration to specify a command to use.'));
   }
 
 
   /**
    * Ask Phabricator to update the current repository as soon as possible.
    *
    * Calling this method after pushing commits allows Phabricator to discover
    * the commits more quickly, so the system overall is more responsive.
    *
    * @return void
    */
   protected function askForRepositoryUpdate() {
     // If we know which repository we're in, try to tell Phabricator that we
     // pushed commits to it so it can update. This hint can help pull updates
     // more quickly, especially in rarely-used repositories.
     if ($this->getRepositoryPHID()) {
       try {
         $this->getConduit()->callMethodSynchronous(
           'diffusion.looksoon',
           array(
             'repositories' => array($this->getRepositoryPHID()),
           ));
       } catch (ConduitClientException $ex) {
         // If we hit an exception, just ignore it. Likely, we are running
         // against a Phabricator which is too old to support this method.
         // Since this hint is purely advisory, it doesn't matter if it has
         // no effect.
       }
     }
   }
 
   protected function getModernLintDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
     return $map;
   }
 
   protected function getModernUnitDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
 
     $details = idx($map, 'userData');
     if (strlen($details)) {
       $map['details'] = (string)$details;
     }
     unset($map['userData']);
 
     return $map;
   }
 
   private function getModernCommonDictionary(array $map) {
     foreach ($map as $key => $value) {
       if ($value === null) {
         unset($map[$key]);
       }
     }
     return $map;
   }
 
   final public function setConduitEngine(
     ArcanistConduitEngine $conduit_engine) {
     $this->conduitEngine = $conduit_engine;
     return $this;
   }
 
   final public function getConduitEngine() {
     return $this->conduitEngine;
   }
 
   final public function getRepositoryRef() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       // This is a toolset workflow and can always build a repository ref.
     } else {
       if (!$this->getConfigurationManager()->getWorkingCopyIdentity()) {
         return null;
       }
 
       if (!$this->repositoryAPI) {
         return null;
       }
     }
 
     if (!$this->repositoryRef) {
       $ref = id(new ArcanistRepositoryRef())
         ->setPHID($this->getRepositoryPHID())
         ->setBrowseURI($this->getRepositoryURI());
 
       $this->repositoryRef = $ref;
     }
 
     return $this->repositoryRef;
   }
 
   final public function getToolsetKey() {
     return $this->getToolset()->getToolsetKey();
   }
 
   final public function getConfig($key) {
     return $this->getConfigurationSourceList()->getConfig($key);
   }
 
   public function canHandleSignal($signo) {
     return false;
   }
 
   public function handleSignal($signo) {
     return;
   }
 
   final public function newCommand(PhutilExecutableFuture $future) {
     return id(new ArcanistCommand())
       ->setLogEngine($this->getLogEngine())
       ->setExecutableFuture($future);
   }
 
   final public function loadHardpoints(
     $objects,
     $requests) {
     return $this->getRuntime()->loadHardpoints($objects, $requests);
   }
 
   protected function newPrompts() {
     return array();
   }
 
   protected function newPrompt($key) {
     return id(new ArcanistPrompt())
       ->setWorkflow($this)
       ->setKey($key);
   }
 
   public function hasPrompt($key) {
     $map = $this->getPromptMap();
     return isset($map[$key]);
   }
 
   public function getPromptMap() {
     if ($this->promptMap === null) {
       $prompts = $this->newPrompts();
       assert_instances_of($prompts, 'ArcanistPrompt');
 
       // TODO: Move this somewhere modular.
 
       $prompts[] = $this->newPrompt('arc.state.stash')
         ->setDescription(
           pht(
             'Prompts the user to stash changes and continue when the '.
             'working copy has untracked, uncommitted, or unstaged '.
             'changes.'));
 
       // TODO: Swap to ArrayCheck?
 
       $map = array();
       foreach ($prompts as $prompt) {
         $key = $prompt->getKey();
 
         if (isset($map[$key])) {
           throw new Exception(
             pht(
               'Workflow ("%s") generates two prompts with the same '.
               'key ("%s"). Each prompt a workflow generates must have a '.
               'unique key.',
               get_class($this),
               $key));
         }
 
         $map[$key] = $prompt;
       }
 
       $this->promptMap = $map;
     }
 
     return $this->promptMap;
   }
 
   final public function getPrompt($key) {
     $map = $this->getPromptMap();
 
     $prompt = idx($map, $key);
     if (!$prompt) {
       throw new Exception(
         pht(
           'Workflow ("%s") is requesting a prompt ("%s") but it did not '.
           'generate any prompt with that name in "newPrompts()".',
           get_class($this),
           $key));
     }
 
     return clone $prompt;
   }
 
   final protected function getSymbolEngine() {
     return $this->getRuntime()->getSymbolEngine();
   }
 
   final protected function getViewer() {
     return $this->getRuntime()->getViewer();
   }
 
   final protected function readStdin() {
     $log = $this->getLogEngine();
     $log->writeWaitingForInput();
 
     // NOTE: We can't just "file_get_contents()" here because signals don't
     // interrupt it. If the user types "^C", we want to interrupt the read.
 
     $raw_handle = fopen('php://stdin', 'rb');
     $stdin = new PhutilSocketChannel($raw_handle);
 
     while ($stdin->update()) {
       PhutilChannel::waitForAny(array($stdin));
     }
 
     return $stdin->read();
   }
 
   final public function getAbsoluteURI($raw_uri) {
     // TODO: "ArcanistRevisionRef", at least, may return a relative URI.
     // If we get a relative URI, guess the correct absolute URI based on
     // the Conduit URI. This might not be correct for Conduit over SSH.
 
     $raw_uri = new PhutilURI($raw_uri);
     if (!strlen($raw_uri->getDomain())) {
       $base_uri = $this->getConduitEngine()
         ->getConduitURI();
 
       $raw_uri = id(new PhutilURI($base_uri))
         ->setPath($raw_uri->getPath());
     }
 
     $raw_uri = phutil_string_cast($raw_uri);
 
     return $raw_uri;
   }
 
   final public function writeToPager($corpus) {
     $is_tty = (function_exists('posix_isatty') && posix_isatty(STDOUT));
 
     if (!$is_tty) {
       echo $corpus;
     } else {
       $pager = $this->getConfig('pager');
 
       if (!$pager) {
         $pager = array('less', '-R', '--');
       }
 
       // Try to show the content through a pager.
       $err = id(new PhutilExecPassthru('%Ls', $pager))
         ->write($corpus)
         ->resolve();
 
       // If the pager exits with an error, print the content normally.
       if ($err) {
         echo $corpus;
       }
     }
 
     return $this;
   }
 
 }