No OneTemporary
Actions

Size

95 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/scripts/arcanist.php b/scripts/arcanist.php
	index c888fae9..dc2f07b7 100755
	--- a/scripts/arcanist.php
	+++ b/scripts/arcanist.php
	@@ -1,653 +1,655 @@
	#!/usr/bin/env php
	<?php

	sanity_check_environment();

	require_once dirname(__FILE__).'/__init_script__.php';

	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' => 'skip-arcconfig',
	),
	array(
	'name' => 'arcrc-file',
	'param' => 'filename',
	),
	array(
	'name' => 'conduit-uri',
	'param' => 'uri',
	'help' => pht('Connect to Phabricator install specified by __uri__.'),
	),
	array(
	'name' => 'conduit-token',
	'param' => 'token',
	'help' => pht('Use a specific authentication token.'),
	),
	array(
	'name' => 'conduit-version',
	'param' => 'version',
	'help' => pht(
	'(Developers) Mock client version in protocol handshake.'),
	),
	array(
	'name' => 'conduit-timeout',
	'param' => 'timeout',
	'help' => pht('Set Conduit timeout (in seconds).'),
	),
	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.'),
	),
	));

	$config_trace_mode = $base_args->getArg('trace');

	$force_conduit = $base_args->getArg('conduit-uri');
	$force_token = $base_args->getArg('conduit-token');
	$force_conduit_version = $base_args->getArg('conduit-version');
	$conduit_timeout = $base_args->getArg('conduit-timeout');
	$skip_arcconfig = $base_args->getArg('skip-arcconfig');
	$custom_arcrc = $base_args->getArg('arcrc-file');
	$load = $base_args->getArg('load-phutil-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(
	'phutil',
	'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);

	if ($skip_arcconfig) {
	$working_copy = ArcanistWorkingCopyIdentity::newDummyWorkingCopy();
	} else {
	$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_class = $working_copy->getProjectConfig('arcanist_configuration');
	if ($config_class) {
	$config = new $config_class();
	} else {
	$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);

	if ($force_conduit_version) {
	$workflow->forceConduitVersion($force_conduit_version);
	}
	if ($conduit_timeout) {
	$workflow->setConduitTimeout($conduit_timeout);
	}

	$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) {
	- HTTPSFuture::setBlindlyTrustDomains($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:'),
	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;
	}

	$description = implode(' ', $original_argv);
	$credentials = array(
	'user' => $user_name,
	'certificate' => $certificate,
	'description' => $description,
	'token' => $conduit_token,
	);
	$workflow->setConduitCredentials($credentials);

	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:'),
	$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("%s\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;
	}
	$arc_dir = dirname(dirname(__FILE__));
	$error = pht(
	"You are trying to run one copy of Arcanist on another copy of ".
	"Arcanist. This operation is not supported. To execute Arcanist ".
	"operations against this working copy, run `%s` (from the current ".
	"working copy) not some other copy of '%s' (you ran one from '%s').",
	'./bin/arc',
	'arc',
	$arc_dir);
	throw new ArcanistUsageException($error);
	}
	}
	}
	diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
	index 6012daf7..cd419223 100644
	--- a/src/__phutil_library_map__.php
	+++ b/src/__phutil_library_map__.php
	@@ -1,838 +1,840 @@
	<?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(
	'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',
	'ArcanistAliasFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAliasFunctionXHPASTLinterRule.php',
	'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAliasFunctionXHPASTLinterRuleTestCase.php',
	'ArcanistAliasWorkflow' => 'workflow/ArcanistAliasWorkflow.php',
	'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
	'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.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',
	'ArcanistBackoutWorkflow' => 'workflow/ArcanistBackoutWorkflow.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',
	'ArcanistBookmarkWorkflow' => 'workflow/ArcanistBookmarkWorkflow.php',
	'ArcanistBraceFormattingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBraceFormattingXHPASTLinterRule.php',
	'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBraceFormattingXHPASTLinterRuleTestCase.php',
	'ArcanistBranchWorkflow' => 'workflow/ArcanistBranchWorkflow.php',
	'ArcanistBritishTestCase' => 'configuration/__tests__/ArcanistBritishTestCase.php',
	'ArcanistBrowseWorkflow' => 'workflow/ArcanistBrowseWorkflow.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',
	'ArcanistCloseWorkflow' => 'workflow/ArcanistCloseWorkflow.php',
	'ArcanistClosureLinter' => 'lint/linter/ArcanistClosureLinter.php',
	'ArcanistClosureLinterTestCase' => 'lint/linter/__tests__/ArcanistClosureLinterTestCase.php',
	'ArcanistCoffeeLintLinter' => 'lint/linter/ArcanistCoffeeLintLinter.php',
	'ArcanistCoffeeLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCoffeeLintLinterTestCase.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',
	'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',
	'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
	'ArcanistConfigurationDrivenLintEngine' => 'lint/engine/ArcanistConfigurationDrivenLintEngine.php',
	'ArcanistConfigurationDrivenUnitTestEngine' => 'unit/engine/ArcanistConfigurationDrivenUnitTestEngine.php',
	'ArcanistConfigurationManager' => 'configuration/ArcanistConfigurationManager.php',
	'ArcanistConsoleLintRenderer' => 'lint/renderer/ArcanistConsoleLintRenderer.php',
	'ArcanistConstructorParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConstructorParenthesesXHPASTLinterRule.php',
	'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConstructorParenthesesXHPASTLinterRuleTestCase.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',
	'ArcanistDeprecationXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeprecationXHPASTLinterRule.php',
	'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeprecationXHPASTLinterRuleTestCase.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',
	'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',
	'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',
	'ArcanistFeatureWorkflow' => 'workflow/ArcanistFeatureWorkflow.php',
	'ArcanistFileDataRef' => 'upload/ArcanistFileDataRef.php',
	'ArcanistFileUploader' => 'upload/ArcanistFileUploader.php',
	'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
	'ArcanistFilenameLinterTestCase' => 'lint/linter/__tests__/ArcanistFilenameLinterTestCase.php',
	'ArcanistFlagWorkflow' => 'workflow/ArcanistFlagWorkflow.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',
	'ArcanistGitLandEngine' => 'land/ArcanistGitLandEngine.php',
	'ArcanistGitUpstreamPath' => 'repository/api/ArcanistGitUpstreamPath.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',
	'ArcanistHLintLinter' => 'lint/linter/ArcanistHLintLinter.php',
	'ArcanistHLintLinterTestCase' => 'lint/linter/__tests__/ArcanistHLintLinterTestCase.php',
	'ArcanistHelpWorkflow' => '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',
	'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',
	'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',
	'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',
	'ArcanistJSONLintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLintLinterTestCase.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',
	'ArcanistLandEngine' => 'land/ArcanistLandEngine.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',
	'ArcanistLibraryTestCase' => '__tests__/ArcanistLibraryTestCase.php',
	'ArcanistLintEngine' => 'lint/engine/ArcanistLintEngine.php',
	'ArcanistLintMessage' => 'lint/ArcanistLintMessage.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',
	'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
	'ArcanistLogicalOperatorsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLogicalOperatorsXHPASTLinterRule.php',
	'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLogicalOperatorsXHPASTLinterRuleTestCase.php',
	'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLowercaseFunctionsXHPASTLinterRule.php',
	'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase.php',
	'ArcanistMercurialAPI' => 'repository/api/ArcanistMercurialAPI.php',
	'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
	'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
	'ArcanistMergeConflictLinter' => 'lint/linter/ArcanistMergeConflictLinter.php',
	'ArcanistMergeConflictLinterTestCase' => 'lint/linter/__tests__/ArcanistMergeConflictLinterTestCase.php',
	'ArcanistMissingLinterException' => 'lint/linter/exception/ArcanistMissingLinterException.php',
	'ArcanistModifierOrderingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistModifierOrderingXHPASTLinterRule.php',
	'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistModifierOrderingXHPASTLinterRuleTestCase.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',
	'ArcanistNoneLintRenderer' => 'lint/renderer/ArcanistNoneLintRenderer.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',
	'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',
	'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',
	'ArcanistPhrequentWorkflow' => 'workflow/ArcanistPhrequentWorkflow.php',
	'ArcanistPhutilLibraryLinter' => 'lint/linter/ArcanistPhutilLibraryLinter.php',
	'ArcanistPhutilXHPASTLinterStandard' => 'lint/linter/standards/phutil/ArcanistPhutilXHPASTLinterStandard.php',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPlusOperatorOnStringsXHPASTLinterRule.php',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase.php',
	'ArcanistPregQuoteMisuseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPregQuoteMisuseXHPASTLinterRule.php',
	'ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase.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',
	'ArcanistRepositoryAPI' => 'repository/api/ArcanistRepositoryAPI.php',
	'ArcanistRepositoryAPIMiscTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIMiscTestCase.php',
	'ArcanistRepositoryAPIStateTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.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',
	'ArcanistRevertWorkflow' => 'workflow/ArcanistRevertWorkflow.php',
	'ArcanistRuboCopLinter' => 'lint/linter/ArcanistRuboCopLinter.php',
	'ArcanistRuboCopLinterTestCase' => 'lint/linter/__tests__/ArcanistRuboCopLinterTestCase.php',
	'ArcanistRubyLinter' => 'lint/linter/ArcanistRubyLinter.php',
	'ArcanistRubyLinterTestCase' => 'lint/linter/__tests__/ArcanistRubyLinterTestCase.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',
	'ArcanistSettings' => 'configuration/ArcanistSettings.php',
	'ArcanistShellCompleteWorkflow' => 'workflow/ArcanistShellCompleteWorkflow.php',
	'ArcanistSingleLintEngine' => 'lint/engine/ArcanistSingleLintEngine.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',
	'ArcanistStartWorkflow' => 'workflow/ArcanistStartWorkflow.php',
	'ArcanistStaticThisXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistStaticThisXHPASTLinterRule.php',
	'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistStaticThisXHPASTLinterRuleTestCase.php',
	'ArcanistStopWorkflow' => 'workflow/ArcanistStopWorkflow.php',
	'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
	'ArcanistSummaryLintRenderer' => 'lint/renderer/ArcanistSummaryLintRenderer.php',
	'ArcanistSyntaxErrorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSyntaxErrorXHPASTLinterRule.php',
	'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
	'ArcanistTautologicalExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTautologicalExpressionXHPASTLinterRule.php',
	'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTautologicalExpressionXHPASTLinterRuleTestCase.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',
	'ArcanistTimeWorkflow' => 'workflow/ArcanistTimeWorkflow.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',
	'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',
	'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',
	'ArcanistVersionWorkflow' => 'workflow/ArcanistVersionWorkflow.php',
	'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
	'ArcanistWorkflow' => 'workflow/ArcanistWorkflow.php',
	'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.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',
	'CSharpToolsTestEngine' => 'unit/engine/CSharpToolsTestEngine.php',
	'NoseTestEngine' => 'unit/engine/NoseTestEngine.php',
	'PhpunitTestEngine' => 'unit/engine/PhpunitTestEngine.php',
	'PhpunitTestEngineTestCase' => 'unit/engine/__tests__/PhpunitTestEngineTestCase.php',
	'PhutilTestCase' => 'unit/engine/phutil/PhutilTestCase.php',
	'PhutilTestCaseTestCase' => 'unit/engine/phutil/testcase/PhutilTestCaseTestCase.php',
	'PhutilTestSkippedException' => 'unit/engine/phutil/testcase/PhutilTestSkippedException.php',
	'PhutilTestTerminatedException' => 'unit/engine/phutil/testcase/PhutilTestTerminatedException.php',
	'PhutilUnitTestEngine' => 'unit/engine/PhutilUnitTestEngine.php',
	'PhutilUnitTestEngineTestCase' => 'unit/engine/__tests__/PhutilUnitTestEngineTestCase.php',
	'PytestTestEngine' => 'unit/engine/PytestTestEngine.php',
	'XUnitTestEngine' => 'unit/engine/XUnitTestEngine.php',
	'XUnitTestResultParserTestCase' => 'unit/parser/__tests__/XUnitTestResultParserTestCase.php',
	),
	'function' => array(),
	'xmap' => array(
	'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistAliasFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistAliasWorkflow' => 'ArcanistWorkflow',
	'ArcanistAmendWorkflow' => 'ArcanistWorkflow',
	'ArcanistAnoidWorkflow' => 'ArcanistWorkflow',
	'ArcanistArrayCombineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistArraySeparatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistArrayValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBackoutWorkflow' => 'ArcanistWorkflow',
	'ArcanistBaseCommitParser' => 'Phobject',
	'ArcanistBaseCommitParserTestCase' => 'PhutilTestCase',
	'ArcanistBaseXHPASTLinter' => 'ArcanistFutureLinter',
	'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	+ 'ArcanistBlindlyTrustHTTPEngineExtension' => 'PhutilHTTPEngineExtension',
	'ArcanistBookmarkWorkflow' => 'ArcanistFeatureWorkflow',
	'ArcanistBraceFormattingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBranchWorkflow' => 'ArcanistFeatureWorkflow',
	'ArcanistBritishTestCase' => 'PhutilTestCase',
	'ArcanistBrowseWorkflow' => 'ArcanistWorkflow',
	'ArcanistBundle' => 'Phobject',
	'ArcanistBundleTestCase' => 'PhutilTestCase',
	'ArcanistCSSLintLinter' => 'ArcanistExternalLinter',
	'ArcanistCSSLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCSharpLinter' => 'ArcanistLinter',
	'ArcanistCallConduitWorkflow' => 'ArcanistWorkflow',
	'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',
	'ArcanistCloseWorkflow' => 'ArcanistWorkflow',
	'ArcanistClosureLinter' => 'ArcanistExternalLinter',
	'ArcanistClosureLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCoffeeLintLinter' => 'ArcanistExternalLinter',
	'ArcanistCoffeeLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCommentRemover' => 'Phobject',
	'ArcanistCommentRemoverTestCase' => 'PhutilTestCase',
	'ArcanistCommentSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCommentStyleXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
	'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistComposerLinter' => 'ArcanistLinter',
	'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
	'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistConfiguration' => 'Phobject',
	'ArcanistConfigurationDrivenLintEngine' => 'ArcanistLintEngine',
	'ArcanistConfigurationDrivenUnitTestEngine' => 'ArcanistUnitTestEngine',
	'ArcanistConfigurationManager' => 'Phobject',
	'ArcanistConsoleLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistConstructorParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => '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',
	'ArcanistDeprecationXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDiffChange' => 'Phobject',
	'ArcanistDiffChangeType' => 'Phobject',
	'ArcanistDiffHunk' => 'Phobject',
	'ArcanistDiffParser' => 'Phobject',
	'ArcanistDiffParserTestCase' => 'PhutilTestCase',
	'ArcanistDiffUtils' => 'Phobject',
	'ArcanistDiffUtilsTestCase' => 'PhutilTestCase',
	'ArcanistDiffWorkflow' => 'ArcanistWorkflow',
	'ArcanistDifferentialCommitMessage' => 'Phobject',
	'ArcanistDifferentialCommitMessageParserException' => 'Exception',
	'ArcanistDifferentialDependencyGraph' => 'AbstractDirectedGraph',
	'ArcanistDifferentialRevisionHash' => 'Phobject',
	'ArcanistDifferentialRevisionStatus' => 'Phobject',
	'ArcanistDoubleQuoteXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDownloadWorkflow' => 'ArcanistWorkflow',
	'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDynamicDefineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => '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',
	'ArcanistFeatureWorkflow' => 'ArcanistWorkflow',
	'ArcanistFileDataRef' => 'Phobject',
	'ArcanistFileUploader' => 'Phobject',
	'ArcanistFilenameLinter' => 'ArcanistLinter',
	'ArcanistFilenameLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistFlagWorkflow' => 'ArcanistWorkflow',
	'ArcanistFlake8Linter' => 'ArcanistExternalLinter',
	'ArcanistFlake8LinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistFormattedStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistFutureLinter' => 'ArcanistLinter',
	'ArcanistGeneratedLinter' => 'ArcanistLinter',
	'ArcanistGeneratedLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistGetConfigWorkflow' => 'ArcanistWorkflow',
	'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
	'ArcanistGitLandEngine' => 'ArcanistLandEngine',
	'ArcanistGitUpstreamPath' => 'Phobject',
	'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
	'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
	'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
	'ArcanistHLintLinter' => 'ArcanistExternalLinter',
	'ArcanistHLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistHelpWorkflow' => 'ArcanistWorkflow',
	'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistHgClientChannel' => 'PhutilProtocolChannel',
	'ArcanistHgProxyClient' => 'Phobject',
	'ArcanistHgProxyServer' => 'Phobject',
	'ArcanistHgServerChannel' => 'PhutilProtocolChannel',
	'ArcanistImplicitConstructorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistImplicitFallthroughXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistImplicitVisibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInlineHTMLXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInnerFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'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',
	'ArcanistJSONLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistJSONLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistJSONLinter' => 'ArcanistLinter',
	'ArcanistJSONLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistJscsLinter' => 'ArcanistExternalLinter',
	'ArcanistJscsLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistKeywordCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLandEngine' => 'Phobject',
	'ArcanistLandWorkflow' => 'ArcanistWorkflow',
	'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLesscLinter' => 'ArcanistExternalLinter',
	'ArcanistLesscLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistLiberateWorkflow' => 'ArcanistWorkflow',
	'ArcanistLibraryTestCase' => 'PhutilLibraryTestCase',
	'ArcanistLintEngine' => 'Phobject',
	'ArcanistLintMessage' => 'Phobject',
	'ArcanistLintPatcher' => 'Phobject',
	'ArcanistLintRenderer' => 'Phobject',
	'ArcanistLintResult' => 'Phobject',
	'ArcanistLintSeverity' => 'Phobject',
	'ArcanistLintWorkflow' => 'ArcanistWorkflow',
	'ArcanistLinter' => 'Phobject',
	'ArcanistLinterStandard' => 'Phobject',
	'ArcanistLinterStandardTestCase' => 'PhutilTestCase',
	'ArcanistLinterTestCase' => 'PhutilTestCase',
	'ArcanistLintersWorkflow' => 'ArcanistWorkflow',
	'ArcanistListAssignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistListWorkflow' => 'ArcanistWorkflow',
	'ArcanistLogicalOperatorsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
	'ArcanistMercurialParser' => 'Phobject',
	'ArcanistMercurialParserTestCase' => 'PhutilTestCase',
	'ArcanistMergeConflictLinter' => 'ArcanistLinter',
	'ArcanistMergeConflictLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistMissingLinterException' => 'Exception',
	'ArcanistModifierOrderingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'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',
	'ArcanistNoneLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPEP8Linter' => 'ArcanistExternalLinter',
	'ArcanistPEP8LinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPHPCloseTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'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',
	'ArcanistPasteWorkflow' => 'ArcanistWorkflow',
	'ArcanistPatchWorkflow' => 'ArcanistWorkflow',
	'ArcanistPhpLinter' => 'ArcanistExternalLinter',
	'ArcanistPhpLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPhpcsLinter' => 'ArcanistExternalLinter',
	'ArcanistPhpcsLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPhpunitTestResultParser' => 'ArcanistTestResultParser',
	'ArcanistPhrequentWorkflow' => 'ArcanistWorkflow',
	'ArcanistPhutilLibraryLinter' => 'ArcanistLinter',
	'ArcanistPhutilXHPASTLinterStandard' => 'ArcanistLinterStandard',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPregQuoteMisuseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPublicPropertyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPuppetLintLinter' => 'ArcanistExternalLinter',
	'ArcanistPuppetLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPyFlakesLinter' => 'ArcanistExternalLinter',
	'ArcanistPyFlakesLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPyLintLinter' => 'ArcanistExternalLinter',
	'ArcanistPyLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistRepositoryAPI' => 'Phobject',
	'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
	'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
	'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistRevertWorkflow' => 'ArcanistWorkflow',
	'ArcanistRuboCopLinter' => 'ArcanistExternalLinter',
	'ArcanistRuboCopLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistRubyLinter' => 'ArcanistExternalLinter',
	'ArcanistRubyLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistScriptAndRegexLinter' => 'ArcanistLinter',
	'ArcanistSelfClassReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSemicolonSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSetConfigWorkflow' => 'ArcanistWorkflow',
	'ArcanistSettings' => 'Phobject',
	'ArcanistShellCompleteWorkflow' => 'ArcanistWorkflow',
	'ArcanistSingleLintEngine' => 'ArcanistLintEngine',
	'ArcanistSlownessXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSlownessXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSpellingLinter' => 'ArcanistLinter',
	'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistStartWorkflow' => 'ArcanistPhrequentWorkflow',
	'ArcanistStaticThisXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistStopWorkflow' => 'ArcanistPhrequentWorkflow',
	'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
	'ArcanistSummaryLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistSyntaxErrorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistTasksWorkflow' => 'ArcanistWorkflow',
	'ArcanistTautologicalExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTestResultParser' => 'Phobject',
	'ArcanistTestXHPASTLintSwitchHook' => 'ArcanistXHPASTLintSwitchHook',
	'ArcanistTextLinter' => 'ArcanistLinter',
	'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistThisReassignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTimeWorkflow' => 'ArcanistPhrequentWorkflow',
	'ArcanistToStringExceptionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTodoCommentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTodoWorkflow' => 'ArcanistWorkflow',
	'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' => 'ArcanistWorkflow',
	'ArcanistUploadWorkflow' => 'ArcanistWorkflow',
	'ArcanistUsageException' => 'Exception',
	'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUserAbortException' => 'ArcanistUsageException',
	'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistVariableVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistVersionWorkflow' => 'ArcanistWorkflow',
	'ArcanistWhichWorkflow' => 'ArcanistWorkflow',
	'ArcanistWorkflow' => 'Phobject',
	'ArcanistWorkingCopyIdentity' => 'Phobject',
	'ArcanistXHPASTLintNamingHook' => 'Phobject',
	'ArcanistXHPASTLintNamingHookTestCase' => 'PhutilTestCase',
	'ArcanistXHPASTLintSwitchHook' => 'Phobject',
	'ArcanistXHPASTLinter' => 'ArcanistBaseXHPASTLinter',
	'ArcanistXHPASTLinterRule' => 'Phobject',
	'ArcanistXHPASTLinterRuleTestCase' => 'ArcanistLinterTestCase',
	'ArcanistXHPASTLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistXMLLinter' => 'ArcanistLinter',
	'ArcanistXMLLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistXUnitTestResultParser' => 'Phobject',
	'CSharpToolsTestEngine' => 'XUnitTestEngine',
	'NoseTestEngine' => 'ArcanistUnitTestEngine',
	'PhpunitTestEngine' => 'ArcanistUnitTestEngine',
	'PhpunitTestEngineTestCase' => 'PhutilTestCase',
	'PhutilTestCase' => 'Phobject',
	'PhutilTestCaseTestCase' => 'PhutilTestCase',
	'PhutilTestSkippedException' => 'Exception',
	'PhutilTestTerminatedException' => 'Exception',
	'PhutilUnitTestEngine' => 'ArcanistUnitTestEngine',
	'PhutilUnitTestEngineTestCase' => 'PhutilTestCase',
	'PytestTestEngine' => 'ArcanistUnitTestEngine',
	'XUnitTestEngine' => 'ArcanistUnitTestEngine',
	'XUnitTestResultParserTestCase' => 'PhutilTestCase',
	),
	));
	diff --git a/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php b/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
	new file mode 100644
	index 00000000..098d04a2
	--- /dev/null
	+++ b/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
	@@ -0,0 +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');
	+ }
	+
	+ public function shouldTrustAnySSLAuthorityForURI(PhutilURI $uri) {
	+ $domain = $uri->getDomain();
	+ $domain = phutil_utf8_strtolower($domain);
	+ return isset($this->domains[$domain]);
	+ }
	+
	+}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 20:55 (6 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1128658
Default Alt Text: (95 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions