No OneTemporary
Actions

Size

258 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
	index 23a9df4b..9f9914ec 100644
	--- a/src/__phutil_library_map__.php
	+++ b/src/__phutil_library_map__.php
	@@ -1,1990 +1,1994 @@
	<?php

	/**
	* This file is automatically generated. Use 'arc liberate' to rebuild it.
	*
	* @generated
	* @phutil-library-version 2
	*/
	phutil_register_library_map(array(
	'__library_version__' => 2,
	'class' => array(
	'AASTNode' => 'parser/aast/api/AASTNode.php',
	'AASTNodeList' => 'parser/aast/api/AASTNodeList.php',
	'AASTToken' => 'parser/aast/api/AASTToken.php',
	'AASTTree' => 'parser/aast/api/AASTTree.php',
	'AbstractDirectedGraph' => 'utils/AbstractDirectedGraph.php',
	'AbstractDirectedGraphTestCase' => 'utils/__tests__/AbstractDirectedGraphTestCase.php',
	'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAbstractMethodBodyXHPASTLinterRule.php',
	'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase.php',
	'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAbstractPrivateMethodXHPASTLinterRule.php',
	'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase.php',
	'ArcanistAlias' => 'toolset/ArcanistAlias.php',
	'ArcanistAliasEffect' => 'toolset/ArcanistAliasEffect.php',
	'ArcanistAliasEngine' => 'toolset/ArcanistAliasEngine.php',
	'ArcanistAliasFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAliasFunctionXHPASTLinterRule.php',
	'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAliasFunctionXHPASTLinterRuleTestCase.php',
	'ArcanistAliasWorkflow' => 'toolset/workflow/ArcanistAliasWorkflow.php',
	'ArcanistAliasesConfigOption' => 'config/option/ArcanistAliasesConfigOption.php',
	'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
	'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.php',
	'ArcanistArcConfigurationEngineExtension' => 'config/arc/ArcanistArcConfigurationEngineExtension.php',
	'ArcanistArcToolset' => 'toolset/ArcanistArcToolset.php',
	'ArcanistArcWorkflow' => 'toolset/workflow/ArcanistArcWorkflow.php',
	'ArcanistArrayCombineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayCombineXHPASTLinterRule.php',
	'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayCombineXHPASTLinterRuleTestCase.php',
	'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayIndexSpacingXHPASTLinterRule.php',
	'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistArraySeparatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArraySeparatorXHPASTLinterRule.php',
	'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArraySeparatorXHPASTLinterRuleTestCase.php',
	'ArcanistArrayValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayValueXHPASTLinterRule.php',
	'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayValueXHPASTLinterRuleTestCase.php',
	'ArcanistBaseCommitParser' => 'parser/ArcanistBaseCommitParser.php',
	'ArcanistBaseCommitParserTestCase' => 'parser/__tests__/ArcanistBaseCommitParserTestCase.php',
	'ArcanistBaseXHPASTLinter' => 'lint/linter/ArcanistBaseXHPASTLinter.php',
	'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryExpressionSpacingXHPASTLinterRule.php',
	'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryNumericScalarCasingXHPASTLinterRule.php',
	'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase.php',
	'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBlacklistedFunctionXHPASTLinterRule.php',
	'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase.php',
	'ArcanistBlindlyTrustHTTPEngineExtension' => 'configuration/ArcanistBlindlyTrustHTTPEngineExtension.php',
	'ArcanistBookmarksWorkflow' => 'workflow/ArcanistBookmarksWorkflow.php',
	'ArcanistBoolConfigOption' => 'config/option/ArcanistBoolConfigOption.php',
	'ArcanistBraceFormattingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBraceFormattingXHPASTLinterRule.php',
	'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBraceFormattingXHPASTLinterRuleTestCase.php',
	'ArcanistBranchesWorkflow' => 'workflow/ArcanistBranchesWorkflow.php',
	'ArcanistBrowseCommitHardpointQuery' => 'browse/query/ArcanistBrowseCommitHardpointQuery.php',
	'ArcanistBrowseCommitURIHardpointQuery' => 'browse/query/ArcanistBrowseCommitURIHardpointQuery.php',
	'ArcanistBrowseObjectNameURIHardpointQuery' => 'browse/query/ArcanistBrowseObjectNameURIHardpointQuery.php',
	'ArcanistBrowsePathURIHardpointQuery' => 'browse/query/ArcanistBrowsePathURIHardpointQuery.php',
	'ArcanistBrowseRef' => 'browse/ref/ArcanistBrowseRef.php',
	'ArcanistBrowseRefInspector' => 'inspector/ArcanistBrowseRefInspector.php',
	'ArcanistBrowseRevisionURIHardpointQuery' => 'browse/query/ArcanistBrowseRevisionURIHardpointQuery.php',
	'ArcanistBrowseURIHardpointQuery' => 'browse/query/ArcanistBrowseURIHardpointQuery.php',
	'ArcanistBrowseURIRef' => 'browse/ref/ArcanistBrowseURIRef.php',
	'ArcanistBrowseWorkflow' => 'browse/workflow/ArcanistBrowseWorkflow.php',
	'ArcanistBuildBuildplanHardpointQuery' => 'ref/build/ArcanistBuildBuildplanHardpointQuery.php',
	'ArcanistBuildPlanRef' => 'ref/buildplan/ArcanistBuildPlanRef.php',
	'ArcanistBuildPlanSymbolRef' => 'ref/buildplan/ArcanistBuildPlanSymbolRef.php',
	'ArcanistBuildRef' => 'ref/build/ArcanistBuildRef.php',
	'ArcanistBuildSymbolRef' => 'ref/build/ArcanistBuildSymbolRef.php',
	'ArcanistBuildableBuildsHardpointQuery' => 'ref/buildable/ArcanistBuildableBuildsHardpointQuery.php',
	'ArcanistBuildableRef' => 'ref/buildable/ArcanistBuildableRef.php',
	'ArcanistBuildableSymbolRef' => 'ref/buildable/ArcanistBuildableSymbolRef.php',
	'ArcanistBundle' => 'parser/ArcanistBundle.php',
	'ArcanistBundleTestCase' => 'parser/__tests__/ArcanistBundleTestCase.php',
	'ArcanistCSSLintLinter' => 'lint/linter/ArcanistCSSLintLinter.php',
	'ArcanistCSSLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCSSLintLinterTestCase.php',
	'ArcanistCSharpLinter' => 'lint/linter/ArcanistCSharpLinter.php',
	'ArcanistCallConduitWorkflow' => 'workflow/ArcanistCallConduitWorkflow.php',
	'ArcanistCallParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallParenthesesXHPASTLinterRule.php',
	'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallParenthesesXHPASTLinterRuleTestCase.php',
	'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallTimePassByReferenceXHPASTLinterRule.php',
	'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase.php',
	'ArcanistCapabilityNotSupportedException' => 'workflow/exception/ArcanistCapabilityNotSupportedException.php',
	'ArcanistCastSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCastSpacingXHPASTLinterRule.php',
	'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCastSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistCheckstyleXMLLintRenderer' => 'lint/renderer/ArcanistCheckstyleXMLLintRenderer.php',
	'ArcanistChmodLinter' => 'lint/linter/ArcanistChmodLinter.php',
	'ArcanistChmodLinterTestCase' => 'lint/linter/__tests__/ArcanistChmodLinterTestCase.php',
	'ArcanistClassExtendsObjectXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassExtendsObjectXHPASTLinterRule.php',
	'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassExtendsObjectXHPASTLinterRuleTestCase.php',
	'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassFilenameMismatchXHPASTLinterRule.php',
	'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule.php',
	'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase.php',
	'ArcanistClassNameLiteralXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassNameLiteralXHPASTLinterRule.php',
	'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassNameLiteralXHPASTLinterRuleTestCase.php',
	'ArcanistCloseRevisionWorkflow' => 'workflow/ArcanistCloseRevisionWorkflow.php',
	'ArcanistClosureLinter' => 'lint/linter/ArcanistClosureLinter.php',
	'ArcanistClosureLinterTestCase' => 'lint/linter/__tests__/ArcanistClosureLinterTestCase.php',
	'ArcanistCoffeeLintLinter' => 'lint/linter/ArcanistCoffeeLintLinter.php',
	'ArcanistCoffeeLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCoffeeLintLinterTestCase.php',
	'ArcanistCommand' => 'toolset/command/ArcanistCommand.php',
	'ArcanistCommentRemover' => 'parser/ArcanistCommentRemover.php',
	'ArcanistCommentRemoverTestCase' => 'parser/__tests__/ArcanistCommentRemoverTestCase.php',
	'ArcanistCommentSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentSpacingXHPASTLinterRule.php',
	'ArcanistCommentStyleXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentStyleXHPASTLinterRule.php',
	'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCommentStyleXHPASTLinterRuleTestCase.php',
	'ArcanistCommitGraph' => 'repository/graph/ArcanistCommitGraph.php',
	'ArcanistCommitGraphPartition' => 'repository/graph/ArcanistCommitGraphPartition.php',
	'ArcanistCommitGraphPartitionQuery' => 'repository/graph/ArcanistCommitGraphPartitionQuery.php',
	'ArcanistCommitGraphQuery' => 'repository/graph/query/ArcanistCommitGraphQuery.php',
	'ArcanistCommitGraphSet' => 'repository/graph/ArcanistCommitGraphSet.php',
	'ArcanistCommitGraphSetQuery' => 'repository/graph/ArcanistCommitGraphSetQuery.php',
	'ArcanistCommitGraphSetTreeView' => 'repository/graph/view/ArcanistCommitGraphSetTreeView.php',
	'ArcanistCommitGraphSetView' => 'repository/graph/view/ArcanistCommitGraphSetView.php',
	'ArcanistCommitGraphTestCase' => 'repository/graph/__tests__/ArcanistCommitGraphTestCase.php',
	'ArcanistCommitNode' => 'repository/graph/ArcanistCommitNode.php',
	'ArcanistCommitRef' => 'ref/commit/ArcanistCommitRef.php',
	'ArcanistCommitSymbolRef' => 'ref/commit/ArcanistCommitSymbolRef.php',
	'ArcanistCommitSymbolRefInspector' => 'ref/commit/ArcanistCommitSymbolRefInspector.php',
	'ArcanistCommitUpstreamHardpointQuery' => 'query/ArcanistCommitUpstreamHardpointQuery.php',
	'ArcanistCommitWorkflow' => 'workflow/ArcanistCommitWorkflow.php',
	'ArcanistCompilerLintRenderer' => 'lint/renderer/ArcanistCompilerLintRenderer.php',
	'ArcanistComposerLinter' => 'lint/linter/ArcanistComposerLinter.php',
	'ArcanistComprehensiveLintEngine' => 'lint/engine/ArcanistComprehensiveLintEngine.php',
	'ArcanistConcatenationOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConcatenationOperatorXHPASTLinterRule.php',
	'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConcatenationOperatorXHPASTLinterRuleTestCase.php',
	'ArcanistConduitAuthenticationException' => 'exception/ArcanistConduitAuthenticationException.php',
	'ArcanistConduitCallFuture' => 'conduit/ArcanistConduitCallFuture.php',
	'ArcanistConduitEngine' => 'conduit/ArcanistConduitEngine.php',
	'ArcanistConduitException' => 'conduit/ArcanistConduitException.php',
	'ArcanistConfigOption' => 'config/option/ArcanistConfigOption.php',
	'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
	'ArcanistConfigurationDrivenLintEngine' => 'lint/engine/ArcanistConfigurationDrivenLintEngine.php',
	'ArcanistConfigurationDrivenUnitTestEngine' => 'unit/engine/ArcanistConfigurationDrivenUnitTestEngine.php',
	'ArcanistConfigurationEngine' => 'config/ArcanistConfigurationEngine.php',
	'ArcanistConfigurationEngineExtension' => 'config/ArcanistConfigurationEngineExtension.php',
	'ArcanistConfigurationManager' => 'configuration/ArcanistConfigurationManager.php',
	'ArcanistConfigurationSource' => 'config/source/ArcanistConfigurationSource.php',
	'ArcanistConfigurationSourceList' => 'config/ArcanistConfigurationSourceList.php',
	'ArcanistConfigurationSourceValue' => 'config/ArcanistConfigurationSourceValue.php',
	'ArcanistConsoleLintRenderer' => 'lint/renderer/ArcanistConsoleLintRenderer.php',
	'ArcanistConsoleLintRendererTestCase' => 'lint/renderer/__tests__/ArcanistConsoleLintRendererTestCase.php',
	'ArcanistConstructorParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConstructorParenthesesXHPASTLinterRule.php',
	'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConstructorParenthesesXHPASTLinterRuleTestCase.php',
	'ArcanistContinueInsideSwitchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistContinueInsideSwitchXHPASTLinterRule.php',
	'ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase.php',
	'ArcanistControlStatementSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistControlStatementSpacingXHPASTLinterRule.php',
	'ArcanistControlStatementSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistControlStatementSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistCoverWorkflow' => 'workflow/ArcanistCoverWorkflow.php',
	'ArcanistCppcheckLinter' => 'lint/linter/ArcanistCppcheckLinter.php',
	'ArcanistCppcheckLinterTestCase' => 'lint/linter/__tests__/ArcanistCppcheckLinterTestCase.php',
	'ArcanistCpplintLinter' => 'lint/linter/ArcanistCpplintLinter.php',
	'ArcanistCpplintLinterTestCase' => 'lint/linter/__tests__/ArcanistCpplintLinterTestCase.php',
	'ArcanistCurlyBraceArrayIndexXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCurlyBraceArrayIndexXHPASTLinterRule.php',
	'ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase.php',
	'ArcanistDeclarationParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeclarationParenthesesXHPASTLinterRule.php',
	'ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase.php',
	'ArcanistDefaultParametersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDefaultParametersXHPASTLinterRule.php',
	'ArcanistDefaultParametersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDefaultParametersXHPASTLinterRuleTestCase.php',
	'ArcanistDefaultsConfigurationSource' => 'config/source/ArcanistDefaultsConfigurationSource.php',
	'ArcanistDeprecationXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeprecationXHPASTLinterRule.php',
	'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeprecationXHPASTLinterRuleTestCase.php',
	'ArcanistDictionaryConfigurationSource' => 'config/source/ArcanistDictionaryConfigurationSource.php',
	'ArcanistDiffByteSizeException' => 'exception/ArcanistDiffByteSizeException.php',
	'ArcanistDiffChange' => 'parser/diff/ArcanistDiffChange.php',
	'ArcanistDiffChangeType' => 'parser/diff/ArcanistDiffChangeType.php',
	'ArcanistDiffHunk' => 'parser/diff/ArcanistDiffHunk.php',
	'ArcanistDiffParser' => 'parser/ArcanistDiffParser.php',
	'ArcanistDiffParserTestCase' => 'parser/__tests__/ArcanistDiffParserTestCase.php',
	'ArcanistDiffUtils' => 'difference/ArcanistDiffUtils.php',
	'ArcanistDiffUtilsTestCase' => 'difference/__tests__/ArcanistDiffUtilsTestCase.php',
	'ArcanistDiffVectorNode' => 'difference/ArcanistDiffVectorNode.php',
	'ArcanistDiffVectorTree' => 'difference/ArcanistDiffVectorTree.php',
	'ArcanistDiffWorkflow' => 'workflow/ArcanistDiffWorkflow.php',
	'ArcanistDifferentialCommitMessage' => 'differential/ArcanistDifferentialCommitMessage.php',
	'ArcanistDifferentialCommitMessageParserException' => 'differential/ArcanistDifferentialCommitMessageParserException.php',
	'ArcanistDifferentialDependencyGraph' => 'differential/ArcanistDifferentialDependencyGraph.php',
	'ArcanistDifferentialRevisionHash' => 'differential/constants/ArcanistDifferentialRevisionHash.php',
	'ArcanistDifferentialRevisionStatus' => 'differential/constants/ArcanistDifferentialRevisionStatus.php',
	'ArcanistDoubleQuoteXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDoubleQuoteXHPASTLinterRule.php',
	'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDoubleQuoteXHPASTLinterRuleTestCase.php',
	'ArcanistDownloadWorkflow' => 'workflow/ArcanistDownloadWorkflow.php',
	'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateKeysInArrayXHPASTLinterRule.php',
	'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase.php',
	'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateSwitchCaseXHPASTLinterRule.php',
	'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase.php',
	'ArcanistDynamicDefineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDynamicDefineXHPASTLinterRule.php',
	'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDynamicDefineXHPASTLinterRuleTestCase.php',
	'ArcanistElseIfUsageXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistElseIfUsageXHPASTLinterRule.php',
	'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistElseIfUsageXHPASTLinterRuleTestCase.php',
	'ArcanistEmptyFileXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyFileXHPASTLinterRule.php',
	'ArcanistEmptyStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyStatementXHPASTLinterRule.php',
	'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistEmptyStatementXHPASTLinterRuleTestCase.php',
	'ArcanistEventType' => 'events/constant/ArcanistEventType.php',
	'ArcanistExitExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExitExpressionXHPASTLinterRule.php',
	'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExitExpressionXHPASTLinterRuleTestCase.php',
	'ArcanistExportWorkflow' => 'workflow/ArcanistExportWorkflow.php',
	'ArcanistExternalLinter' => 'lint/linter/ArcanistExternalLinter.php',
	'ArcanistExternalLinterTestCase' => 'lint/linter/__tests__/ArcanistExternalLinterTestCase.php',
	'ArcanistExtractUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExtractUseXHPASTLinterRule.php',
	'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExtractUseXHPASTLinterRuleTestCase.php',
	'ArcanistFileConfigurationSource' => 'config/source/ArcanistFileConfigurationSource.php',
	'ArcanistFileDataRef' => 'upload/ArcanistFileDataRef.php',
	'ArcanistFileRef' => 'ref/file/ArcanistFileRef.php',
	'ArcanistFileSymbolRef' => 'ref/file/ArcanistFileSymbolRef.php',
	'ArcanistFileUploader' => 'upload/ArcanistFileUploader.php',
	'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
	'ArcanistFilenameLinterTestCase' => 'lint/linter/__tests__/ArcanistFilenameLinterTestCase.php',
	'ArcanistFilesystemAPI' => 'repository/api/ArcanistFilesystemAPI.php',
	'ArcanistFilesystemConfigurationSource' => 'config/source/ArcanistFilesystemConfigurationSource.php',
	'ArcanistFilesystemWorkingCopy' => 'workingcopy/ArcanistFilesystemWorkingCopy.php',
	'ArcanistFlake8Linter' => 'lint/linter/ArcanistFlake8Linter.php',
	'ArcanistFlake8LinterTestCase' => 'lint/linter/__tests__/ArcanistFlake8LinterTestCase.php',
	'ArcanistFormattedStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFormattedStringXHPASTLinterRule.php',
	'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFormattedStringXHPASTLinterRuleTestCase.php',
	'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule.php',
	'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase.php',
	'ArcanistFutureLinter' => 'lint/linter/ArcanistFutureLinter.php',
	'ArcanistGeneratedLinter' => 'lint/linter/ArcanistGeneratedLinter.php',
	'ArcanistGeneratedLinterTestCase' => 'lint/linter/__tests__/ArcanistGeneratedLinterTestCase.php',
	'ArcanistGetConfigWorkflow' => 'workflow/ArcanistGetConfigWorkflow.php',
	'ArcanistGitAPI' => 'repository/api/ArcanistGitAPI.php',
	'ArcanistGitCommitGraphQuery' => 'repository/graph/query/ArcanistGitCommitGraphQuery.php',
	'ArcanistGitCommitMessageHardpointQuery' => 'query/ArcanistGitCommitMessageHardpointQuery.php',
	'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ref/commit/ArcanistGitCommitSymbolCommitHardpointQuery.php',
	'ArcanistGitLandEngine' => 'land/engine/ArcanistGitLandEngine.php',
	'ArcanistGitLocalState' => 'repository/state/ArcanistGitLocalState.php',
	'ArcanistGitRawCommit' => 'repository/raw/ArcanistGitRawCommit.php',
	'ArcanistGitRawCommitTestCase' => 'repository/raw/__tests__/ArcanistGitRawCommitTestCase.php',
	'ArcanistGitRepositoryMarkerQuery' => 'repository/marker/ArcanistGitRepositoryMarkerQuery.php',
	'ArcanistGitRepositoryRemoteQuery' => 'repository/remote/ArcanistGitRepositoryRemoteQuery.php',
	'ArcanistGitUpstreamPath' => 'repository/api/ArcanistGitUpstreamPath.php',
	'ArcanistGitWorkEngine' => 'work/ArcanistGitWorkEngine.php',
	'ArcanistGitWorkingCopy' => 'workingcopy/ArcanistGitWorkingCopy.php',
	'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'query/ArcanistGitWorkingCopyRevisionHardpointQuery.php',
	'ArcanistGlobalVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistGlobalVariableXHPASTLinterRule.php',
	'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistGlobalVariableXHPASTLinterRuleTestCase.php',
	'ArcanistGoLintLinter' => 'lint/linter/ArcanistGoLintLinter.php',
	'ArcanistGoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistGoLintLinterTestCase.php',
	'ArcanistGoTestResultParser' => 'unit/parser/ArcanistGoTestResultParser.php',
	'ArcanistGoTestResultParserTestCase' => 'unit/parser/__tests__/ArcanistGoTestResultParserTestCase.php',
	'ArcanistGridCell' => 'console/grid/ArcanistGridCell.php',
	'ArcanistGridColumn' => 'console/grid/ArcanistGridColumn.php',
	'ArcanistGridRow' => 'console/grid/ArcanistGridRow.php',
	'ArcanistGridView' => 'console/grid/ArcanistGridView.php',
	'ArcanistHLintLinter' => 'lint/linter/ArcanistHLintLinter.php',
	'ArcanistHLintLinterTestCase' => 'lint/linter/__tests__/ArcanistHLintLinterTestCase.php',
	'ArcanistHardpoint' => 'hardpoint/ArcanistHardpoint.php',
	'ArcanistHardpointEngine' => 'hardpoint/ArcanistHardpointEngine.php',
	'ArcanistHardpointFutureList' => 'hardpoint/ArcanistHardpointFutureList.php',
	'ArcanistHardpointList' => 'hardpoint/ArcanistHardpointList.php',
	'ArcanistHardpointObject' => 'hardpoint/ArcanistHardpointObject.php',
	'ArcanistHardpointQuery' => 'hardpoint/ArcanistHardpointQuery.php',
	'ArcanistHardpointRequest' => 'hardpoint/ArcanistHardpointRequest.php',
	'ArcanistHardpointRequestList' => 'hardpoint/ArcanistHardpointRequestList.php',
	'ArcanistHardpointTask' => 'hardpoint/ArcanistHardpointTask.php',
	'ArcanistHardpointTaskResult' => 'hardpoint/ArcanistHardpointTaskResult.php',
	'ArcanistHelpWorkflow' => 'toolset/workflow/ArcanistHelpWorkflow.php',
	'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule.php',
	'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase.php',
	'ArcanistHgClientChannel' => 'hgdaemon/ArcanistHgClientChannel.php',
	'ArcanistHgProxyClient' => 'hgdaemon/ArcanistHgProxyClient.php',
	'ArcanistHgProxyServer' => 'hgdaemon/ArcanistHgProxyServer.php',
	'ArcanistHgServerChannel' => 'hgdaemon/ArcanistHgServerChannel.php',
	'ArcanistImplicitConstructorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitConstructorXHPASTLinterRule.php',
	'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitConstructorXHPASTLinterRuleTestCase.php',
	'ArcanistImplicitFallthroughXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitFallthroughXHPASTLinterRule.php',
	'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitFallthroughXHPASTLinterRuleTestCase.php',
	'ArcanistImplicitVisibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitVisibilityXHPASTLinterRule.php',
	'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitVisibilityXHPASTLinterRuleTestCase.php',
	'ArcanistImplodeArgumentOrderXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplodeArgumentOrderXHPASTLinterRule.php',
	'ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase.php',
	'ArcanistInlineHTMLXHPASTLinterRule' => 'lint/linter/ArcanistInlineHTMLXHPASTLinterRule.php',
	'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInlineHTMLXHPASTLinterRuleTestCase.php',
	'ArcanistInnerFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInnerFunctionXHPASTLinterRule.php',
	'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInnerFunctionXHPASTLinterRuleTestCase.php',
	'ArcanistInspectWorkflow' => 'workflow/ArcanistInspectWorkflow.php',
	'ArcanistInstallCertificateWorkflow' => 'workflow/ArcanistInstallCertificateWorkflow.php',
	'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInstanceOfOperatorXHPASTLinterRule.php',
	'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInstanceofOperatorXHPASTLinterRuleTestCase.php',
	'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceAbstractMethodXHPASTLinterRule.php',
	'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase.php',
	'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceMethodBodyXHPASTLinterRule.php',
	'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase.php',
	'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidDefaultParameterXHPASTLinterRule.php',
	'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase.php',
	'ArcanistInvalidModifiersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidModifiersXHPASTLinterRule.php',
	'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidModifiersXHPASTLinterRuleTestCase.php',
	'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidOctalNumericScalarXHPASTLinterRule.php',
	'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase.php',
	'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistIsAShouldBeInstanceOfXHPASTLinterRule.php',
	'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase.php',
	'ArcanistJSHintLinter' => 'lint/linter/ArcanistJSHintLinter.php',
	'ArcanistJSHintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSHintLinterTestCase.php',
	'ArcanistJSONLintLinter' => 'lint/linter/ArcanistJSONLintLinter.php',
	'ArcanistJSONLintRenderer' => 'lint/renderer/ArcanistJSONLintRenderer.php',
	'ArcanistJSONLinter' => 'lint/linter/ArcanistJSONLinter.php',
	'ArcanistJSONLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLinterTestCase.php',
	'ArcanistJscsLinter' => 'lint/linter/ArcanistJscsLinter.php',
	'ArcanistJscsLinterTestCase' => 'lint/linter/__tests__/ArcanistJscsLinterTestCase.php',
	'ArcanistKeywordCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistKeywordCasingXHPASTLinterRule.php',
	'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistKeywordCasingXHPASTLinterRuleTestCase.php',
	'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLambdaFuncFunctionXHPASTLinterRule.php',
	'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase.php',
	'ArcanistLandCommit' => 'land/ArcanistLandCommit.php',
	'ArcanistLandCommitSet' => 'land/ArcanistLandCommitSet.php',
	'ArcanistLandEngine' => 'land/engine/ArcanistLandEngine.php',
	'ArcanistLandPushFailureException' => 'land/exception/ArcanistLandPushFailureException.php',
	'ArcanistLandSymbol' => 'land/ArcanistLandSymbol.php',
	'ArcanistLandTarget' => 'land/ArcanistLandTarget.php',
	'ArcanistLandWorkflow' => 'workflow/ArcanistLandWorkflow.php',
	'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLanguageConstructParenthesesXHPASTLinterRule.php',
	'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase.php',
	'ArcanistLesscLinter' => 'lint/linter/ArcanistLesscLinter.php',
	'ArcanistLesscLinterTestCase' => 'lint/linter/__tests__/ArcanistLesscLinterTestCase.php',
	'ArcanistLiberateWorkflow' => 'workflow/ArcanistLiberateWorkflow.php',
	'ArcanistLintEngine' => 'lint/engine/ArcanistLintEngine.php',
	'ArcanistLintMessage' => 'lint/ArcanistLintMessage.php',
	'ArcanistLintMessageTestCase' => 'lint/__tests__/ArcanistLintMessageTestCase.php',
	'ArcanistLintPatcher' => 'lint/ArcanistLintPatcher.php',
	'ArcanistLintRenderer' => 'lint/renderer/ArcanistLintRenderer.php',
	'ArcanistLintResult' => 'lint/ArcanistLintResult.php',
	'ArcanistLintSeverity' => 'lint/ArcanistLintSeverity.php',
	'ArcanistLintWorkflow' => 'workflow/ArcanistLintWorkflow.php',
	'ArcanistLinter' => 'lint/linter/ArcanistLinter.php',
	'ArcanistLinterStandard' => 'lint/linter/standards/ArcanistLinterStandard.php',
	'ArcanistLinterStandardTestCase' => 'lint/linter/standards/__tests__/ArcanistLinterStandardTestCase.php',
	'ArcanistLinterTestCase' => 'lint/linter/__tests__/ArcanistLinterTestCase.php',
	'ArcanistLintersWorkflow' => 'workflow/ArcanistLintersWorkflow.php',
	'ArcanistListAssignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistListAssignmentXHPASTLinterRule.php',
	'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistListAssignmentXHPASTLinterRuleTestCase.php',
	'ArcanistListConfigOption' => 'config/option/ArcanistListConfigOption.php',
	'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
	'ArcanistLocalConfigurationSource' => 'config/source/ArcanistLocalConfigurationSource.php',
	'ArcanistLogEngine' => 'log/ArcanistLogEngine.php',
	'ArcanistLogMessage' => 'log/ArcanistLogMessage.php',
	'ArcanistLogicalOperatorsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLogicalOperatorsXHPASTLinterRule.php',
	'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLogicalOperatorsXHPASTLinterRuleTestCase.php',
	'ArcanistLookWorkflow' => 'workflow/ArcanistLookWorkflow.php',
	'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLowercaseFunctionsXHPASTLinterRule.php',
	'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase.php',
	'ArcanistMarkerRef' => 'repository/marker/ArcanistMarkerRef.php',
	'ArcanistMarkersWorkflow' => 'workflow/ArcanistMarkersWorkflow.php',
	'ArcanistMercurialAPI' => 'repository/api/ArcanistMercurialAPI.php',
	'ArcanistMercurialCommitGraphQuery' => 'repository/graph/query/ArcanistMercurialCommitGraphQuery.php',
	'ArcanistMercurialCommitMessageHardpointQuery' => 'query/ArcanistMercurialCommitMessageHardpointQuery.php',
	'ArcanistMercurialLandEngine' => 'land/engine/ArcanistMercurialLandEngine.php',
	'ArcanistMercurialLocalState' => 'repository/state/ArcanistMercurialLocalState.php',
	'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
	'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
	'ArcanistMercurialRepositoryMarkerQuery' => 'repository/marker/ArcanistMercurialRepositoryMarkerQuery.php',
	'ArcanistMercurialRepositoryRemoteQuery' => 'repository/remote/ArcanistMercurialRepositoryRemoteQuery.php',
	'ArcanistMercurialWorkEngine' => 'work/ArcanistMercurialWorkEngine.php',
	'ArcanistMercurialWorkingCopy' => 'workingcopy/ArcanistMercurialWorkingCopy.php',
	'ArcanistMercurialWorkingCopyRevisionHardpointQuery' => 'query/ArcanistMercurialWorkingCopyRevisionHardpointQuery.php',
	'ArcanistMergeConflictLinter' => 'lint/linter/ArcanistMergeConflictLinter.php',
	'ArcanistMergeConflictLinterTestCase' => 'lint/linter/__tests__/ArcanistMergeConflictLinterTestCase.php',
	'ArcanistMessageRevisionHardpointQuery' => 'query/ArcanistMessageRevisionHardpointQuery.php',
	'ArcanistMissingArgumentTerminatorException' => 'exception/ArcanistMissingArgumentTerminatorException.php',
	'ArcanistMissingLinterException' => 'lint/linter/exception/ArcanistMissingLinterException.php',
	'ArcanistModifierOrderingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistModifierOrderingXHPASTLinterRule.php',
	'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistModifierOrderingXHPASTLinterRuleTestCase.php',
	'ArcanistMultiSourceConfigOption' => 'config/option/ArcanistMultiSourceConfigOption.php',
	'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamespaceFirstStatementXHPASTLinterRule.php',
	'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase.php',
	'ArcanistNamingConventionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamingConventionsXHPASTLinterRule.php',
	'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamingConventionsXHPASTLinterRuleTestCase.php',
	'ArcanistNestedNamespacesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNestedNamespacesXHPASTLinterRule.php',
	'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNestedNamespacesXHPASTLinterRuleTestCase.php',
	'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNewlineAfterOpenTagXHPASTLinterRule.php',
	'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase.php',
	'ArcanistNoEffectException' => 'exception/usage/ArcanistNoEffectException.php',
	'ArcanistNoEngineException' => 'exception/usage/ArcanistNoEngineException.php',
	'ArcanistNoLintLinter' => 'lint/linter/ArcanistNoLintLinter.php',
	'ArcanistNoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistNoLintLinterTestCase.php',
	'ArcanistNoParentScopeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNoParentScopeXHPASTLinterRule.php',
	'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNoParentScopeXHPASTLinterRuleTestCase.php',
	'ArcanistNoURIConduitException' => 'conduit/ArcanistNoURIConduitException.php',
	'ArcanistNoneLintRenderer' => 'lint/renderer/ArcanistNoneLintRenderer.php',
	'ArcanistObjectListHardpoint' => 'hardpoint/ArcanistObjectListHardpoint.php',
	'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistObjectOperatorSpacingXHPASTLinterRule.php',
	'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistPEP8Linter' => 'lint/linter/ArcanistPEP8Linter.php',
	'ArcanistPEP8LinterTestCase' => 'lint/linter/__tests__/ArcanistPEP8LinterTestCase.php',
	'ArcanistPHPCloseTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCloseTagXHPASTLinterRule.php',
	'ArcanistPHPCloseTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPCloseTagXHPASTLinterRuleTestCase.php',
	'ArcanistPHPCompatibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCompatibilityXHPASTLinterRule.php',
	'ArcanistPHPCompatibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPCompatibilityXHPASTLinterRuleTestCase.php',
	'ArcanistPHPEchoTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPEchoTagXHPASTLinterRule.php',
	'ArcanistPHPEchoTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPEchoTagXHPASTLinterRuleTestCase.php',
	'ArcanistPHPOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPOpenTagXHPASTLinterRule.php',
	'ArcanistPHPOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPOpenTagXHPASTLinterRuleTestCase.php',
	'ArcanistPHPShortTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPShortTagXHPASTLinterRule.php',
	'ArcanistPHPShortTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPShortTagXHPASTLinterRuleTestCase.php',
	'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule.php',
	'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistParentMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParentMemberReferenceXHPASTLinterRule.php',
	'ArcanistParentMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParentMemberReferenceXHPASTLinterRuleTestCase.php',
	'ArcanistParenthesesSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParenthesesSpacingXHPASTLinterRule.php',
	'ArcanistParenthesesSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParenthesesSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistParseStrUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParseStrUseXHPASTLinterRule.php',
	'ArcanistParseStrUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParseStrUseXHPASTLinterRuleTestCase.php',
	'ArcanistPasteRef' => 'ref/paste/ArcanistPasteRef.php',
	'ArcanistPasteSymbolRef' => 'ref/paste/ArcanistPasteSymbolRef.php',
	'ArcanistPasteWorkflow' => 'workflow/ArcanistPasteWorkflow.php',
	'ArcanistPatchWorkflow' => 'workflow/ArcanistPatchWorkflow.php',
	'ArcanistPhpLinter' => 'lint/linter/ArcanistPhpLinter.php',
	'ArcanistPhpLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpLinterTestCase.php',
	'ArcanistPhpcsLinter' => 'lint/linter/ArcanistPhpcsLinter.php',
	'ArcanistPhpcsLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpcsLinterTestCase.php',
	'ArcanistPhpunitTestResultParser' => 'unit/parser/ArcanistPhpunitTestResultParser.php',
	'ArcanistPhutilLibraryLinter' => 'lint/linter/ArcanistPhutilLibraryLinter.php',
	'ArcanistPhutilWorkflow' => 'toolset/ArcanistPhutilWorkflow.php',
	'ArcanistPhutilXHPASTLinterStandard' => 'lint/linter/standards/phutil/ArcanistPhutilXHPASTLinterStandard.php',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPlusOperatorOnStringsXHPASTLinterRule.php',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase.php',
	'ArcanistProjectConfigurationSource' => 'config/source/ArcanistProjectConfigurationSource.php',
	'ArcanistPrompt' => 'toolset/ArcanistPrompt.php',
	'ArcanistPromptResponse' => 'toolset/ArcanistPromptResponse.php',
	'ArcanistPromptsConfigOption' => 'config/option/ArcanistPromptsConfigOption.php',
	'ArcanistPromptsWorkflow' => 'toolset/workflow/ArcanistPromptsWorkflow.php',
	'ArcanistPublicPropertyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPublicPropertyXHPASTLinterRule.php',
	'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPublicPropertyXHPASTLinterRuleTestCase.php',
	'ArcanistPuppetLintLinter' => 'lint/linter/ArcanistPuppetLintLinter.php',
	'ArcanistPuppetLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPuppetLintLinterTestCase.php',
	'ArcanistPyFlakesLinter' => 'lint/linter/ArcanistPyFlakesLinter.php',
	'ArcanistPyFlakesLinterTestCase' => 'lint/linter/__tests__/ArcanistPyFlakesLinterTestCase.php',
	'ArcanistPyLintLinter' => 'lint/linter/ArcanistPyLintLinter.php',
	'ArcanistPyLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPyLintLinterTestCase.php',
	'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistRaggedClassTreeEdgeXHPASTLinterRule.php',
	'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase.php',
	'ArcanistRef' => 'ref/ArcanistRef.php',
	'ArcanistRefInspector' => 'inspector/ArcanistRefInspector.php',
	'ArcanistRefView' => 'ref/ArcanistRefView.php',
	'ArcanistRemoteRef' => 'repository/remote/ArcanistRemoteRef.php',
	'ArcanistRemoteRefInspector' => 'repository/remote/ArcanistRemoteRefInspector.php',
	'ArcanistRemoteRepositoryRefsHardpointQuery' => 'repository/remote/ArcanistRemoteRepositoryRefsHardpointQuery.php',
	'ArcanistRepositoryAPI' => 'repository/api/ArcanistRepositoryAPI.php',
	'ArcanistRepositoryAPIMiscTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIMiscTestCase.php',
	'ArcanistRepositoryAPIStateTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php',
	'ArcanistRepositoryLocalState' => 'repository/state/ArcanistRepositoryLocalState.php',
	'ArcanistRepositoryMarkerQuery' => 'repository/marker/ArcanistRepositoryMarkerQuery.php',
	'ArcanistRepositoryQuery' => 'repository/query/ArcanistRepositoryQuery.php',
	'ArcanistRepositoryRef' => 'ref/ArcanistRepositoryRef.php',
	'ArcanistRepositoryRemoteQuery' => 'repository/remote/ArcanistRepositoryRemoteQuery.php',
	'ArcanistRepositoryURINormalizer' => 'repository/remote/ArcanistRepositoryURINormalizer.php',
	'ArcanistRepositoryURINormalizerTestCase' => 'repository/remote/__tests__/ArcanistRepositoryURINormalizerTestCase.php',
	'ArcanistReusedAsIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedAsIteratorXHPASTLinterRule.php',
	'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedAsIteratorXHPASTLinterRuleTestCase.php',
	'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorReferenceXHPASTLinterRule.php',
	'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase.php',
	'ArcanistReusedIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorXHPASTLinterRule.php',
	'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorXHPASTLinterRuleTestCase.php',
	'ArcanistRevisionAuthorHardpointQuery' => 'ref/revision/ArcanistRevisionAuthorHardpointQuery.php',
	'ArcanistRevisionBuildableHardpointQuery' => 'ref/revision/ArcanistRevisionBuildableHardpointQuery.php',
	'ArcanistRevisionCommitMessageHardpointQuery' => 'ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php',
	'ArcanistRevisionParentRevisionsHardpointQuery' => 'ref/revision/ArcanistRevisionParentRevisionsHardpointQuery.php',
	'ArcanistRevisionRef' => 'ref/revision/ArcanistRevisionRef.php',
	'ArcanistRevisionRefSource' => 'ref/ArcanistRevisionRefSource.php',
	'ArcanistRevisionSymbolRef' => 'ref/revision/ArcanistRevisionSymbolRef.php',
	'ArcanistRuboCopLinter' => 'lint/linter/ArcanistRuboCopLinter.php',
	'ArcanistRuboCopLinterTestCase' => 'lint/linter/__tests__/ArcanistRuboCopLinterTestCase.php',
	'ArcanistRubyLinter' => 'lint/linter/ArcanistRubyLinter.php',
	'ArcanistRubyLinterTestCase' => 'lint/linter/__tests__/ArcanistRubyLinterTestCase.php',
	'ArcanistRuntime' => 'runtime/ArcanistRuntime.php',
	'ArcanistRuntimeConfigurationSource' => 'config/source/ArcanistRuntimeConfigurationSource.php',
	'ArcanistRuntimeHardpointQuery' => 'toolset/query/ArcanistRuntimeHardpointQuery.php',
	'ArcanistScalarHardpoint' => 'hardpoint/ArcanistScalarHardpoint.php',
	'ArcanistScriptAndRegexLinter' => 'lint/linter/ArcanistScriptAndRegexLinter.php',
	'ArcanistSelfClassReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfClassReferenceXHPASTLinterRule.php',
	'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfClassReferenceXHPASTLinterRuleTestCase.php',
	'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfMemberReferenceXHPASTLinterRule.php',
	'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase.php',
	'ArcanistSemicolonSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSemicolonSpacingXHPASTLinterRule.php',
	'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSemicolonSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistSetConfigWorkflow' => 'workflow/ArcanistSetConfigWorkflow.php',
	'ArcanistSetting' => 'configuration/ArcanistSetting.php',
	'ArcanistSettings' => 'configuration/ArcanistSettings.php',
	'ArcanistShellCompleteWorkflow' => 'toolset/workflow/ArcanistShellCompleteWorkflow.php',
	'ArcanistSimpleCommitGraphQuery' => 'repository/graph/query/ArcanistSimpleCommitGraphQuery.php',
	'ArcanistSimpleSymbolHardpointQuery' => 'ref/simple/ArcanistSimpleSymbolHardpointQuery.php',
	'ArcanistSimpleSymbolRef' => 'ref/simple/ArcanistSimpleSymbolRef.php',
	'ArcanistSimpleSymbolRefInspector' => 'ref/simple/ArcanistSimpleSymbolRefInspector.php',
	'ArcanistSingleLintEngine' => 'lint/engine/ArcanistSingleLintEngine.php',
	'ArcanistSingleSourceConfigOption' => 'config/option/ArcanistSingleSourceConfigOption.php',
	'ArcanistSlownessXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSlownessXHPASTLinterRule.php',
	'ArcanistSlownessXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSlownessXHPASTLinterRuleTestCase.php',
	'ArcanistSpellingLinter' => 'lint/linter/ArcanistSpellingLinter.php',
	'ArcanistSpellingLinterTestCase' => 'lint/linter/__tests__/ArcanistSpellingLinterTestCase.php',
	'ArcanistStaticThisXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistStaticThisXHPASTLinterRule.php',
	'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistStaticThisXHPASTLinterRuleTestCase.php',
	'ArcanistStringConfigOption' => 'config/option/ArcanistStringConfigOption.php',
	'ArcanistStringListConfigOption' => 'config/option/ArcanistStringListConfigOption.php',
	'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
	'ArcanistSubversionWorkingCopy' => 'workingcopy/ArcanistSubversionWorkingCopy.php',
	'ArcanistSummaryLintRenderer' => 'lint/renderer/ArcanistSummaryLintRenderer.php',
	'ArcanistSymbolEngine' => 'ref/symbol/ArcanistSymbolEngine.php',
	'ArcanistSymbolRef' => 'ref/symbol/ArcanistSymbolRef.php',
	'ArcanistSyntaxErrorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSyntaxErrorXHPASTLinterRule.php',
	'ArcanistSystemConfigurationSource' => 'config/source/ArcanistSystemConfigurationSource.php',
	'ArcanistTaskRef' => 'ref/task/ArcanistTaskRef.php',
	'ArcanistTaskSymbolRef' => 'ref/task/ArcanistTaskSymbolRef.php',
	'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
	'ArcanistTautologicalExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTautologicalExpressionXHPASTLinterRule.php',
	'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTautologicalExpressionXHPASTLinterRuleTestCase.php',
	'ArcanistTerminalStringInterface' => 'xsprintf/ArcanistTerminalStringInterface.php',
	'ArcanistTestResultParser' => 'unit/parser/ArcanistTestResultParser.php',
	'ArcanistTestXHPASTLintSwitchHook' => 'lint/linter/__tests__/ArcanistTestXHPASTLintSwitchHook.php',
	'ArcanistTextLinter' => 'lint/linter/ArcanistTextLinter.php',
	'ArcanistTextLinterTestCase' => 'lint/linter/__tests__/ArcanistTextLinterTestCase.php',
	'ArcanistThisReassignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistThisReassignmentXHPASTLinterRule.php',
	'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistThisReassignmentXHPASTLinterRuleTestCase.php',
	'ArcanistToStringExceptionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistToStringExceptionXHPASTLinterRule.php',
	'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistToStringExceptionXHPASTLinterRuleTestCase.php',
	'ArcanistTodoCommentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTodoCommentXHPASTLinterRule.php',
	'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTodoCommentXHPASTLinterRuleTestCase.php',
	'ArcanistTodoWorkflow' => 'workflow/ArcanistTodoWorkflow.php',
	'ArcanistToolset' => 'toolset/ArcanistToolset.php',
	'ArcanistUSEnglishTranslation' => 'internationalization/ArcanistUSEnglishTranslation.php',
	'ArcanistUnableToParseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnableToParseXHPASTLinterRule.php',
	'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule.php',
	'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule.php',
	'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistUndeclaredVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUndeclaredVariableXHPASTLinterRule.php',
	'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUndeclaredVariableXHPASTLinterRuleTestCase.php',
	'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnexpectedReturnValueXHPASTLinterRule.php',
	'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase.php',
	'ArcanistUnitConsoleRenderer' => 'unit/renderer/ArcanistUnitConsoleRenderer.php',
	'ArcanistUnitRenderer' => 'unit/renderer/ArcanistUnitRenderer.php',
	'ArcanistUnitTestEngine' => 'unit/engine/ArcanistUnitTestEngine.php',
	'ArcanistUnitTestResult' => 'unit/ArcanistUnitTestResult.php',
	'ArcanistUnitTestResultTestCase' => 'unit/__tests__/ArcanistUnitTestResultTestCase.php',
	'ArcanistUnitTestableLintEngine' => 'lint/engine/ArcanistUnitTestableLintEngine.php',
	'ArcanistUnitWorkflow' => 'workflow/ArcanistUnitWorkflow.php',
	'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessaryFinalModifierXHPASTLinterRule.php',
	'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase.php',
	'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySemicolonXHPASTLinterRule.php',
	'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySymbolAliasXHPASTLinterRule.php',
	'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase.php',
	'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnsafeDynamicStringXHPASTLinterRule.php',
	'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase.php',
	'ArcanistUpgradeWorkflow' => 'workflow/ArcanistUpgradeWorkflow.php',
	'ArcanistUploadWorkflow' => 'workflow/ArcanistUploadWorkflow.php',
	'ArcanistUsageException' => 'exception/ArcanistUsageException.php',
	'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUseStatementNamespacePrefixXHPASTLinterRule.php',
	'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase.php',
	'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUselessOverridingMethodXHPASTLinterRule.php',
	'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase.php',
	'ArcanistUserAbortException' => 'exception/usage/ArcanistUserAbortException.php',
	'ArcanistUserConfigurationSource' => 'config/source/ArcanistUserConfigurationSource.php',
	'ArcanistUserRef' => 'ref/user/ArcanistUserRef.php',
	'ArcanistUserSymbolHardpointQuery' => 'ref/user/ArcanistUserSymbolHardpointQuery.php',
	'ArcanistUserSymbolRef' => 'ref/user/ArcanistUserSymbolRef.php',
	'ArcanistUserSymbolRefInspector' => 'ref/user/ArcanistUserSymbolRefInspector.php',
	'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableReferenceSpacingXHPASTLinterRule.php',
	'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase.php',
	'ArcanistVariableVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableVariableXHPASTLinterRule.php',
	'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableVariableXHPASTLinterRuleTestCase.php',
	'ArcanistVectorHardpoint' => 'hardpoint/ArcanistVectorHardpoint.php',
	'ArcanistVersionWorkflow' => 'toolset/workflow/ArcanistVersionWorkflow.php',
	'ArcanistWeldWorkflow' => 'workflow/ArcanistWeldWorkflow.php',
	'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
	'ArcanistWildConfigOption' => 'config/option/ArcanistWildConfigOption.php',
	'ArcanistWorkEngine' => 'work/ArcanistWorkEngine.php',
	'ArcanistWorkWorkflow' => 'workflow/ArcanistWorkWorkflow.php',
	'ArcanistWorkflow' => 'workflow/ArcanistWorkflow.php',
	'ArcanistWorkflowArgument' => 'toolset/ArcanistWorkflowArgument.php',
	'ArcanistWorkflowEngine' => 'engine/ArcanistWorkflowEngine.php',
	'ArcanistWorkflowGitHardpointQuery' => 'query/ArcanistWorkflowGitHardpointQuery.php',
	'ArcanistWorkflowInformation' => 'toolset/ArcanistWorkflowInformation.php',
	'ArcanistWorkflowMercurialHardpointQuery' => 'query/ArcanistWorkflowMercurialHardpointQuery.php',
	'ArcanistWorkingCopy' => 'workingcopy/ArcanistWorkingCopy.php',
	'ArcanistWorkingCopyConfigurationSource' => 'config/source/ArcanistWorkingCopyConfigurationSource.php',
	'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.php',
	'ArcanistWorkingCopyPath' => 'workingcopy/ArcanistWorkingCopyPath.php',
	'ArcanistWorkingCopyStateRef' => 'ref/ArcanistWorkingCopyStateRef.php',
	'ArcanistWorkingCopyStateRefInspector' => 'inspector/ArcanistWorkingCopyStateRefInspector.php',
	'ArcanistXHPASTLintNamingHook' => 'lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php',
	'ArcanistXHPASTLintNamingHookTestCase' => 'lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php',
	'ArcanistXHPASTLintSwitchHook' => 'lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php',
	'ArcanistXHPASTLinter' => 'lint/linter/ArcanistXHPASTLinter.php',
	'ArcanistXHPASTLinterRule' => 'lint/linter/xhpast/ArcanistXHPASTLinterRule.php',
	'ArcanistXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php',
	'ArcanistXHPASTLinterTestCase' => 'lint/linter/__tests__/ArcanistXHPASTLinterTestCase.php',
	'ArcanistXMLLinter' => 'lint/linter/ArcanistXMLLinter.php',
	'ArcanistXMLLinterTestCase' => 'lint/linter/__tests__/ArcanistXMLLinterTestCase.php',
	'ArcanistXUnitTestResultParser' => 'unit/parser/ArcanistXUnitTestResultParser.php',
	'BaseHTTPFuture' => 'future/http/BaseHTTPFuture.php',
	'CSharpToolsTestEngine' => 'unit/engine/CSharpToolsTestEngine.php',
	'CaseInsensitiveArray' => 'utils/CaseInsensitiveArray.php',
	'CaseInsensitiveArrayTestCase' => 'utils/__tests__/CaseInsensitiveArrayTestCase.php',
	'CommandException' => 'future/exec/CommandException.php',
	'ConduitClient' => 'conduit/ConduitClient.php',
	'ConduitClientException' => 'conduit/ConduitClientException.php',
	'ConduitClientTestCase' => 'conduit/__tests__/ConduitClientTestCase.php',
	'ConduitFuture' => 'conduit/ConduitFuture.php',
	'ConduitSearchFuture' => 'conduit/ConduitSearchFuture.php',
	'ExecFuture' => 'future/exec/ExecFuture.php',
	'ExecFutureTestCase' => 'future/exec/__tests__/ExecFutureTestCase.php',
	'ExecPassthruTestCase' => 'future/exec/__tests__/ExecPassthruTestCase.php',
	'FileFinder' => 'filesystem/FileFinder.php',
	'FileFinderTestCase' => 'filesystem/__tests__/FileFinderTestCase.php',
	'FileList' => 'filesystem/FileList.php',
	'Filesystem' => 'filesystem/Filesystem.php',
	'FilesystemException' => 'filesystem/FilesystemException.php',
	'FilesystemTestCase' => 'filesystem/__tests__/FilesystemTestCase.php',
	'Future' => 'future/Future.php',
	'FutureAgent' => 'conduit/FutureAgent.php',
	'FutureIterator' => 'future/FutureIterator.php',
	'FutureIteratorTestCase' => 'future/__tests__/FutureIteratorTestCase.php',
	'FuturePool' => 'future/FuturePool.php',
	'FutureProxy' => 'future/FutureProxy.php',
	'HTTPFuture' => 'future/http/HTTPFuture.php',
	'HTTPFutureCURLResponseStatus' => 'future/http/status/HTTPFutureCURLResponseStatus.php',
	'HTTPFutureCertificateResponseStatus' => 'future/http/status/HTTPFutureCertificateResponseStatus.php',
	'HTTPFutureHTTPResponseStatus' => 'future/http/status/HTTPFutureHTTPResponseStatus.php',
	'HTTPFutureParseResponseStatus' => 'future/http/status/HTTPFutureParseResponseStatus.php',
	'HTTPFutureResponseStatus' => 'future/http/status/HTTPFutureResponseStatus.php',
	'HTTPFutureTransportResponseStatus' => 'future/http/status/HTTPFutureTransportResponseStatus.php',
	'HTTPSFuture' => 'future/http/HTTPSFuture.php',
	'ImmediateFuture' => 'future/ImmediateFuture.php',
	'LibphutilUSEnglishTranslation' => 'internationalization/translation/LibphutilUSEnglishTranslation.php',
	'LinesOfALarge' => 'filesystem/linesofalarge/LinesOfALarge.php',
	'LinesOfALargeExecFuture' => 'filesystem/linesofalarge/LinesOfALargeExecFuture.php',
	'LinesOfALargeExecFutureTestCase' => 'filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php',
	'LinesOfALargeFile' => 'filesystem/linesofalarge/LinesOfALargeFile.php',
	'LinesOfALargeFileTestCase' => 'filesystem/linesofalarge/__tests__/LinesOfALargeFileTestCase.php',
	'MFilterTestHelper' => 'utils/__tests__/MFilterTestHelper.php',
	'NoseTestEngine' => 'unit/engine/NoseTestEngine.php',
	'PHPASTParserTestCase' => 'parser/xhpast/__tests__/PHPASTParserTestCase.php',
	'PhageAction' => 'phage/action/PhageAction.php',
	'PhageAgentAction' => 'phage/action/PhageAgentAction.php',
	'PhageAgentBootloader' => 'phage/bootloader/PhageAgentBootloader.php',
	'PhageAgentTestCase' => 'phage/__tests__/PhageAgentTestCase.php',
	'PhageExecWorkflow' => 'phage/workflow/PhageExecWorkflow.php',
	'PhageExecuteAction' => 'phage/action/PhageExecuteAction.php',
	'PhageLocalAction' => 'phage/action/PhageLocalAction.php',
	'PhagePHPAgent' => 'phage/agent/PhagePHPAgent.php',
	'PhagePHPAgentBootloader' => 'phage/bootloader/PhagePHPAgentBootloader.php',
	'PhagePlanAction' => 'phage/action/PhagePlanAction.php',
	'PhageToolset' => 'phage/toolset/PhageToolset.php',
	'PhageWorkflow' => 'phage/workflow/PhageWorkflow.php',
	'Phobject' => 'object/Phobject.php',
	'PhobjectTestCase' => 'object/__tests__/PhobjectTestCase.php',
	'PhpunitTestEngine' => 'unit/engine/PhpunitTestEngine.php',
	'PhpunitTestEngineTestCase' => 'unit/engine/__tests__/PhpunitTestEngineTestCase.php',
	'PhutilAWSCloudFormationFuture' => 'future/aws/PhutilAWSCloudFormationFuture.php',
	'PhutilAWSCloudWatchFuture' => 'future/aws/PhutilAWSCloudWatchFuture.php',
	'PhutilAWSEC2Future' => 'future/aws/PhutilAWSEC2Future.php',
	'PhutilAWSException' => 'future/aws/PhutilAWSException.php',
	'PhutilAWSFuture' => 'future/aws/PhutilAWSFuture.php',
	'PhutilAWSManagementWorkflow' => 'future/aws/management/PhutilAWSManagementWorkflow.php',
	'PhutilAWSS3DeleteManagementWorkflow' => 'future/aws/management/PhutilAWSS3DeleteManagementWorkflow.php',
	'PhutilAWSS3Future' => 'future/aws/PhutilAWSS3Future.php',
	'PhutilAWSS3GetManagementWorkflow' => 'future/aws/management/PhutilAWSS3GetManagementWorkflow.php',
	'PhutilAWSS3ManagementWorkflow' => 'future/aws/management/PhutilAWSS3ManagementWorkflow.php',
	'PhutilAWSS3PutManagementWorkflow' => 'future/aws/management/PhutilAWSS3PutManagementWorkflow.php',
	'PhutilAWSv4Signature' => 'future/aws/PhutilAWSv4Signature.php',
	'PhutilAWSv4SignatureTestCase' => 'future/aws/__tests__/PhutilAWSv4SignatureTestCase.php',
	'PhutilAggregateException' => 'error/PhutilAggregateException.php',
	'PhutilAllCapsEnglishLocale' => 'internationalization/locales/PhutilAllCapsEnglishLocale.php',
	'PhutilArgumentParser' => 'parser/argument/PhutilArgumentParser.php',
	'PhutilArgumentParserException' => 'parser/argument/exception/PhutilArgumentParserException.php',
	'PhutilArgumentParserTestCase' => 'parser/argument/__tests__/PhutilArgumentParserTestCase.php',
	'PhutilArgumentSpecification' => 'parser/argument/PhutilArgumentSpecification.php',
	'PhutilArgumentSpecificationException' => 'parser/argument/exception/PhutilArgumentSpecificationException.php',
	'PhutilArgumentSpecificationTestCase' => 'parser/argument/__tests__/PhutilArgumentSpecificationTestCase.php',
	'PhutilArgumentSpellingCorrector' => 'parser/argument/PhutilArgumentSpellingCorrector.php',
	'PhutilArgumentSpellingCorrectorTestCase' => 'parser/argument/__tests__/PhutilArgumentSpellingCorrectorTestCase.php',
	'PhutilArgumentUsageException' => 'parser/argument/exception/PhutilArgumentUsageException.php',
	'PhutilArgumentWorkflow' => 'parser/argument/workflow/PhutilArgumentWorkflow.php',
	'PhutilArray' => 'utils/PhutilArray.php',
	'PhutilArrayCheck' => 'utils/PhutilArrayCheck.php',
	'PhutilArrayTestCase' => 'utils/__tests__/PhutilArrayTestCase.php',
	'PhutilArrayWithDefaultValue' => 'utils/PhutilArrayWithDefaultValue.php',
	'PhutilAsanaFuture' => 'future/asana/PhutilAsanaFuture.php',
	'PhutilBacktraceSignalHandler' => 'future/exec/PhutilBacktraceSignalHandler.php',
	'PhutilBallOfPHP' => 'phage/util/PhutilBallOfPHP.php',
	'PhutilBinaryAnalyzer' => 'filesystem/binary/PhutilBinaryAnalyzer.php',
	'PhutilBinaryAnalyzerTestCase' => 'filesystem/binary/__tests__/PhutilBinaryAnalyzerTestCase.php',
	'PhutilBootloader' => 'init/lib/PhutilBootloader.php',
	'PhutilBootloaderException' => 'init/lib/PhutilBootloaderException.php',
	'PhutilBritishEnglishLocale' => 'internationalization/locales/PhutilBritishEnglishLocale.php',
	'PhutilBufferedIterator' => 'utils/PhutilBufferedIterator.php',
	'PhutilBufferedIteratorTestCase' => 'utils/__tests__/PhutilBufferedIteratorTestCase.php',
	'PhutilBugtraqParser' => 'parser/PhutilBugtraqParser.php',
	'PhutilBugtraqParserTestCase' => 'parser/__tests__/PhutilBugtraqParserTestCase.php',
	'PhutilCIDRBlock' => 'ip/PhutilCIDRBlock.php',
	'PhutilCIDRList' => 'ip/PhutilCIDRList.php',
	'PhutilCallbackFilterIterator' => 'utils/PhutilCallbackFilterIterator.php',
	'PhutilCallbackSignalHandler' => 'future/exec/PhutilCallbackSignalHandler.php',
	'PhutilChannel' => 'channel/PhutilChannel.php',
	'PhutilChannelChannel' => 'channel/PhutilChannelChannel.php',
	'PhutilChannelTestCase' => 'channel/__tests__/PhutilChannelTestCase.php',
	'PhutilChunkedIterator' => 'utils/PhutilChunkedIterator.php',
	'PhutilChunkedIteratorTestCase' => 'utils/__tests__/PhutilChunkedIteratorTestCase.php',
	'PhutilClassMapQuery' => 'symbols/PhutilClassMapQuery.php',
	'PhutilCloudWatchMetric' => 'future/aws/PhutilCloudWatchMetric.php',
	'PhutilCommandString' => 'xsprintf/PhutilCommandString.php',
	'PhutilConsole' => 'console/PhutilConsole.php',
	'PhutilConsoleBlock' => 'console/view/PhutilConsoleBlock.php',
	'PhutilConsoleError' => 'console/view/PhutilConsoleError.php',
	'PhutilConsoleFormatter' => 'console/PhutilConsoleFormatter.php',
	'PhutilConsoleInfo' => 'console/view/PhutilConsoleInfo.php',
	'PhutilConsoleList' => 'console/view/PhutilConsoleList.php',
	'PhutilConsoleLogLine' => 'console/view/PhutilConsoleLogLine.php',
	'PhutilConsoleMessage' => 'console/PhutilConsoleMessage.php',
	'PhutilConsoleMetrics' => 'console/PhutilConsoleMetrics.php',
	'PhutilConsoleMetricsSignalHandler' => 'future/exec/PhutilConsoleMetricsSignalHandler.php',
	'PhutilConsoleProgressBar' => 'console/PhutilConsoleProgressBar.php',
	'PhutilConsoleProgressSink' => 'progress/PhutilConsoleProgressSink.php',
	'PhutilConsoleServer' => 'console/PhutilConsoleServer.php',
	'PhutilConsoleServerChannel' => 'console/PhutilConsoleServerChannel.php',
	'PhutilConsoleSkip' => 'console/view/PhutilConsoleSkip.php',
	'PhutilConsoleStdinNotInteractiveException' => 'console/PhutilConsoleStdinNotInteractiveException.php',
	'PhutilConsoleTable' => 'console/view/PhutilConsoleTable.php',
	'PhutilConsoleView' => 'console/view/PhutilConsoleView.php',
	'PhutilConsoleWarning' => 'console/view/PhutilConsoleWarning.php',
	'PhutilConsoleWrapTestCase' => 'console/__tests__/PhutilConsoleWrapTestCase.php',
	'PhutilCowsay' => 'utils/PhutilCowsay.php',
	'PhutilCowsayTestCase' => 'utils/__tests__/PhutilCowsayTestCase.php',
	'PhutilCsprintfTestCase' => 'xsprintf/__tests__/PhutilCsprintfTestCase.php',
	'PhutilCzechLocale' => 'internationalization/locales/PhutilCzechLocale.php',
	'PhutilDOMNode' => 'parser/html/PhutilDOMNode.php',
	'PhutilDeferredLog' => 'filesystem/PhutilDeferredLog.php',
	'PhutilDeferredLogTestCase' => 'filesystem/__tests__/PhutilDeferredLogTestCase.php',
	'PhutilDiffBinaryAnalyzer' => 'filesystem/binary/PhutilDiffBinaryAnalyzer.php',
	'PhutilDirectedScalarGraph' => 'utils/PhutilDirectedScalarGraph.php',
	'PhutilDirectoryFixture' => 'filesystem/PhutilDirectoryFixture.php',
	'PhutilDocblockParser' => 'parser/PhutilDocblockParser.php',
	'PhutilDocblockParserTestCase' => 'parser/__tests__/PhutilDocblockParserTestCase.php',
	'PhutilEditDistanceMatrix' => 'utils/PhutilEditDistanceMatrix.php',
	'PhutilEditDistanceMatrixTestCase' => 'utils/__tests__/PhutilEditDistanceMatrixTestCase.php',
	'PhutilEditorConfig' => 'parser/PhutilEditorConfig.php',
	'PhutilEditorConfigTestCase' => 'parser/__tests__/PhutilEditorConfigTestCase.php',
	'PhutilEmailAddress' => 'parser/PhutilEmailAddress.php',
	'PhutilEmailAddressTestCase' => 'parser/__tests__/PhutilEmailAddressTestCase.php',
	'PhutilEmojiLocale' => 'internationalization/locales/PhutilEmojiLocale.php',
	'PhutilEnglishCanadaLocale' => 'internationalization/locales/PhutilEnglishCanadaLocale.php',
	'PhutilErrorHandler' => 'error/PhutilErrorHandler.php',
	'PhutilErrorHandlerTestCase' => 'error/__tests__/PhutilErrorHandlerTestCase.php',
	'PhutilErrorTrap' => 'error/PhutilErrorTrap.php',
	'PhutilEvent' => 'events/PhutilEvent.php',
	'PhutilEventConstants' => 'events/constant/PhutilEventConstants.php',
	'PhutilEventEngine' => 'events/PhutilEventEngine.php',
	'PhutilEventListener' => 'events/PhutilEventListener.php',
	'PhutilEventType' => 'events/constant/PhutilEventType.php',
	'PhutilExampleBufferedIterator' => 'utils/PhutilExampleBufferedIterator.php',
	'PhutilExecChannel' => 'channel/PhutilExecChannel.php',
	'PhutilExecPassthru' => 'future/exec/PhutilExecPassthru.php',
	'PhutilExecutableFuture' => 'future/exec/PhutilExecutableFuture.php',
	'PhutilExecutionEnvironment' => 'utils/PhutilExecutionEnvironment.php',
	'PhutilFileLock' => 'filesystem/PhutilFileLock.php',
	'PhutilFileLockTestCase' => 'filesystem/__tests__/PhutilFileLockTestCase.php',
	'PhutilFrenchLocale' => 'internationalization/locales/PhutilFrenchLocale.php',
	'PhutilGermanLocale' => 'internationalization/locales/PhutilGermanLocale.php',
	'PhutilGitBinaryAnalyzer' => 'filesystem/binary/PhutilGitBinaryAnalyzer.php',
	'PhutilGitHubFuture' => 'future/github/PhutilGitHubFuture.php',
	'PhutilGitHubResponse' => 'future/github/PhutilGitHubResponse.php',
	'PhutilGitURI' => 'parser/PhutilGitURI.php',
	'PhutilGitURITestCase' => 'parser/__tests__/PhutilGitURITestCase.php',
	+ 'PhutilGitsprintfTestCase' => 'xsprintf/__tests__/PhutilGitsprintfTestCase.php',
	'PhutilHTMLParser' => 'parser/html/PhutilHTMLParser.php',
	'PhutilHTMLParserTestCase' => 'parser/html/__tests__/PhutilHTMLParserTestCase.php',
	'PhutilHTTPEngineExtension' => 'future/http/PhutilHTTPEngineExtension.php',
	'PhutilHTTPResponse' => 'parser/http/PhutilHTTPResponse.php',
	'PhutilHTTPResponseParser' => 'parser/http/PhutilHTTPResponseParser.php',
	'PhutilHTTPResponseParserTestCase' => 'parser/http/__tests__/PhutilHTTPResponseParserTestCase.php',
	'PhutilHashingIterator' => 'utils/PhutilHashingIterator.php',
	'PhutilHashingIteratorTestCase' => 'utils/__tests__/PhutilHashingIteratorTestCase.php',
	'PhutilHelpArgumentWorkflow' => 'parser/argument/workflow/PhutilHelpArgumentWorkflow.php',
	'PhutilHgsprintfTestCase' => 'xsprintf/__tests__/PhutilHgsprintfTestCase.php',
	'PhutilINIParserException' => 'parser/exception/PhutilINIParserException.php',
	'PhutilIPAddress' => 'ip/PhutilIPAddress.php',
	'PhutilIPAddressTestCase' => 'ip/__tests__/PhutilIPAddressTestCase.php',
	'PhutilIPv4Address' => 'ip/PhutilIPv4Address.php',
	'PhutilIPv6Address' => 'ip/PhutilIPv6Address.php',
	'PhutilInteractiveEditor' => 'console/PhutilInteractiveEditor.php',
	'PhutilInvalidRuleParserGeneratorException' => 'parser/generator/exception/PhutilInvalidRuleParserGeneratorException.php',
	'PhutilInvalidStateException' => 'exception/PhutilInvalidStateException.php',
	'PhutilInvalidStateExceptionTestCase' => 'exception/__tests__/PhutilInvalidStateExceptionTestCase.php',
	'PhutilIrreducibleRuleParserGeneratorException' => 'parser/generator/exception/PhutilIrreducibleRuleParserGeneratorException.php',
	'PhutilJSON' => 'parser/PhutilJSON.php',
	'PhutilJSONFragmentLexer' => 'lexer/PhutilJSONFragmentLexer.php',
	'PhutilJSONParser' => 'parser/PhutilJSONParser.php',
	'PhutilJSONParserException' => 'parser/exception/PhutilJSONParserException.php',
	'PhutilJSONParserTestCase' => 'parser/__tests__/PhutilJSONParserTestCase.php',
	'PhutilJSONProtocolChannel' => 'channel/PhutilJSONProtocolChannel.php',
	'PhutilJSONProtocolChannelTestCase' => 'channel/__tests__/PhutilJSONProtocolChannelTestCase.php',
	'PhutilJSONTestCase' => 'parser/__tests__/PhutilJSONTestCase.php',
	'PhutilJavaFragmentLexer' => 'lexer/PhutilJavaFragmentLexer.php',
	'PhutilKoreanLocale' => 'internationalization/locales/PhutilKoreanLocale.php',
	'PhutilLanguageGuesser' => 'parser/PhutilLanguageGuesser.php',
	'PhutilLanguageGuesserTestCase' => 'parser/__tests__/PhutilLanguageGuesserTestCase.php',
	'PhutilLexer' => 'lexer/PhutilLexer.php',
	'PhutilLibraryConflictException' => 'init/lib/PhutilLibraryConflictException.php',
	'PhutilLibraryMapBuilder' => 'moduleutils/PhutilLibraryMapBuilder.php',
	'PhutilLibraryTestCase' => '__tests__/PhutilLibraryTestCase.php',
	'PhutilLocale' => 'internationalization/PhutilLocale.php',
	'PhutilLocaleTestCase' => 'internationalization/__tests__/PhutilLocaleTestCase.php',
	'PhutilLock' => 'filesystem/PhutilLock.php',
	'PhutilLockException' => 'filesystem/PhutilLockException.php',
	'PhutilLogFileChannel' => 'channel/PhutilLogFileChannel.php',
	'PhutilLunarPhase' => 'utils/PhutilLunarPhase.php',
	'PhutilLunarPhaseTestCase' => 'utils/__tests__/PhutilLunarPhaseTestCase.php',
	'PhutilMercurialBinaryAnalyzer' => 'filesystem/binary/PhutilMercurialBinaryAnalyzer.php',
	'PhutilMethodNotImplementedException' => 'error/PhutilMethodNotImplementedException.php',
	'PhutilMetricsChannel' => 'channel/PhutilMetricsChannel.php',
	'PhutilMissingSymbolException' => 'init/lib/PhutilMissingSymbolException.php',
	'PhutilModuleUtilsTestCase' => 'init/lib/__tests__/PhutilModuleUtilsTestCase.php',
	'PhutilNumber' => 'internationalization/PhutilNumber.php',
	'PhutilOAuth1Future' => 'future/oauth/PhutilOAuth1Future.php',
	'PhutilOAuth1FutureTestCase' => 'future/oauth/__tests__/PhutilOAuth1FutureTestCase.php',
	'PhutilOpaqueEnvelope' => 'error/PhutilOpaqueEnvelope.php',
	'PhutilOpaqueEnvelopeKey' => 'error/PhutilOpaqueEnvelopeKey.php',
	'PhutilOpaqueEnvelopeTestCase' => 'error/__tests__/PhutilOpaqueEnvelopeTestCase.php',
	'PhutilPHPFragmentLexer' => 'lexer/PhutilPHPFragmentLexer.php',
	'PhutilPHPFragmentLexerTestCase' => 'lexer/__tests__/PhutilPHPFragmentLexerTestCase.php',
	'PhutilPHPObjectProtocolChannel' => 'channel/PhutilPHPObjectProtocolChannel.php',
	'PhutilPHPObjectProtocolChannelTestCase' => 'channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php',
	'PhutilParserGenerator' => 'parser/PhutilParserGenerator.php',
	'PhutilParserGeneratorException' => 'parser/generator/exception/PhutilParserGeneratorException.php',
	'PhutilParserGeneratorTestCase' => 'parser/__tests__/PhutilParserGeneratorTestCase.php',
	'PhutilPayPalAPIFuture' => 'future/paypal/PhutilPayPalAPIFuture.php',
	'PhutilPerson' => 'internationalization/PhutilPerson.php',
	'PhutilPersonTest' => 'internationalization/__tests__/PhutilPersonTest.php',
	'PhutilPhtTestCase' => 'internationalization/__tests__/PhutilPhtTestCase.php',
	'PhutilPirateEnglishLocale' => 'internationalization/locales/PhutilPirateEnglishLocale.php',
	'PhutilPortugueseBrazilLocale' => 'internationalization/locales/PhutilPortugueseBrazilLocale.php',
	'PhutilPortuguesePortugalLocale' => 'internationalization/locales/PhutilPortuguesePortugalLocale.php',
	'PhutilPostmarkFuture' => 'future/postmark/PhutilPostmarkFuture.php',
	'PhutilPregsprintfTestCase' => 'xsprintf/__tests__/PhutilPregsprintfTestCase.php',
	'PhutilProcessQuery' => 'filesystem/PhutilProcessQuery.php',
	'PhutilProcessRef' => 'filesystem/PhutilProcessRef.php',
	'PhutilProcessRefTestCase' => 'filesystem/__tests__/PhutilProcessRefTestCase.php',
	'PhutilProgressSink' => 'progress/PhutilProgressSink.php',
	'PhutilProtocolChannel' => 'channel/PhutilProtocolChannel.php',
	'PhutilProxyException' => 'error/PhutilProxyException.php',
	'PhutilProxyIterator' => 'utils/PhutilProxyIterator.php',
	'PhutilPygmentizeBinaryAnalyzer' => 'filesystem/binary/PhutilPygmentizeBinaryAnalyzer.php',
	'PhutilPythonFragmentLexer' => 'lexer/PhutilPythonFragmentLexer.php',
	'PhutilQueryStringParser' => 'parser/PhutilQueryStringParser.php',
	'PhutilQueryStringParserTestCase' => 'parser/__tests__/PhutilQueryStringParserTestCase.php',
	'PhutilRawEnglishLocale' => 'internationalization/locales/PhutilRawEnglishLocale.php',
	'PhutilReadableSerializer' => 'readableserializer/PhutilReadableSerializer.php',
	'PhutilReadableSerializerTestCase' => 'readableserializer/__tests__/PhutilReadableSerializerTestCase.php',
	'PhutilRope' => 'utils/PhutilRope.php',
	'PhutilRopeTestCase' => 'utils/__tests__/PhutilRopeTestCase.php',
	'PhutilServiceProfiler' => 'serviceprofiler/PhutilServiceProfiler.php',
	'PhutilShellLexer' => 'lexer/PhutilShellLexer.php',
	'PhutilShellLexerTestCase' => 'lexer/__tests__/PhutilShellLexerTestCase.php',
	'PhutilSignalHandler' => 'future/exec/PhutilSignalHandler.php',
	'PhutilSignalRouter' => 'future/exec/PhutilSignalRouter.php',
	'PhutilSimpleOptions' => 'parser/PhutilSimpleOptions.php',
	'PhutilSimpleOptionsLexer' => 'lexer/PhutilSimpleOptionsLexer.php',
	'PhutilSimpleOptionsLexerTestCase' => 'lexer/__tests__/PhutilSimpleOptionsLexerTestCase.php',
	'PhutilSimpleOptionsTestCase' => 'parser/__tests__/PhutilSimpleOptionsTestCase.php',
	'PhutilSimplifiedChineseLocale' => 'internationalization/locales/PhutilSimplifiedChineseLocale.php',
	'PhutilSlackFuture' => 'future/slack/PhutilSlackFuture.php',
	'PhutilSocketChannel' => 'channel/PhutilSocketChannel.php',
	'PhutilSortVector' => 'utils/PhutilSortVector.php',
	'PhutilSpanishSpainLocale' => 'internationalization/locales/PhutilSpanishSpainLocale.php',
	'PhutilStreamIterator' => 'utils/PhutilStreamIterator.php',
	'PhutilSubversionBinaryAnalyzer' => 'filesystem/binary/PhutilSubversionBinaryAnalyzer.php',
	'PhutilSymbolLoader' => 'symbols/PhutilSymbolLoader.php',
	'PhutilSystem' => 'utils/PhutilSystem.php',
	'PhutilSystemTestCase' => 'utils/__tests__/PhutilSystemTestCase.php',
	'PhutilTerminalString' => 'xsprintf/PhutilTerminalString.php',
	'PhutilTestCase' => 'unit/engine/phutil/PhutilTestCase.php',
	'PhutilTestCaseTestCase' => 'unit/engine/phutil/testcase/PhutilTestCaseTestCase.php',
	'PhutilTestPhobject' => 'object/__tests__/PhutilTestPhobject.php',
	'PhutilTestSkippedException' => 'unit/engine/phutil/testcase/PhutilTestSkippedException.php',
	'PhutilTestTerminatedException' => 'unit/engine/phutil/testcase/PhutilTestTerminatedException.php',
	'PhutilTraditionalChineseLocale' => 'internationalization/locales/PhutilTraditionalChineseLocale.php',
	'PhutilTranslation' => 'internationalization/PhutilTranslation.php',
	'PhutilTranslationTestCase' => 'internationalization/__tests__/PhutilTranslationTestCase.php',
	'PhutilTranslator' => 'internationalization/PhutilTranslator.php',
	'PhutilTranslatorTestCase' => 'internationalization/__tests__/PhutilTranslatorTestCase.php',
	'PhutilTsprintfTestCase' => 'xsprintf/__tests__/PhutilTsprintfTestCase.php',
	'PhutilTwitchFuture' => 'future/twitch/PhutilTwitchFuture.php',
	'PhutilTypeCheckException' => 'parser/exception/PhutilTypeCheckException.php',
	'PhutilTypeExtraParametersException' => 'parser/exception/PhutilTypeExtraParametersException.php',
	'PhutilTypeLexer' => 'lexer/PhutilTypeLexer.php',
	'PhutilTypeMissingParametersException' => 'parser/exception/PhutilTypeMissingParametersException.php',
	'PhutilTypeSpec' => 'parser/PhutilTypeSpec.php',
	'PhutilTypeSpecTestCase' => 'parser/__tests__/PhutilTypeSpecTestCase.php',
	'PhutilURI' => 'parser/PhutilURI.php',
	'PhutilURITestCase' => 'parser/__tests__/PhutilURITestCase.php',
	'PhutilUSEnglishLocale' => 'internationalization/locales/PhutilUSEnglishLocale.php',
	'PhutilUTF8StringTruncator' => 'utils/PhutilUTF8StringTruncator.php',
	'PhutilUTF8TestCase' => 'utils/__tests__/PhutilUTF8TestCase.php',
	'PhutilUnitTestEngine' => 'unit/engine/PhutilUnitTestEngine.php',
	'PhutilUnitTestEngineTestCase' => 'unit/engine/__tests__/PhutilUnitTestEngineTestCase.php',
	'PhutilUnknownSymbolParserGeneratorException' => 'parser/generator/exception/PhutilUnknownSymbolParserGeneratorException.php',
	'PhutilUnreachableRuleParserGeneratorException' => 'parser/generator/exception/PhutilUnreachableRuleParserGeneratorException.php',
	'PhutilUnreachableTerminalParserGeneratorException' => 'parser/generator/exception/PhutilUnreachableTerminalParserGeneratorException.php',
	'PhutilUrisprintfTestCase' => 'xsprintf/__tests__/PhutilUrisprintfTestCase.php',
	'PhutilUtilsTestCase' => 'utils/__tests__/PhutilUtilsTestCase.php',
	'PhutilVeryWowEnglishLocale' => 'internationalization/locales/PhutilVeryWowEnglishLocale.php',
	'PhutilWordPressFuture' => 'future/wordpress/PhutilWordPressFuture.php',
	'PhutilXHPASTBinary' => 'parser/xhpast/bin/PhutilXHPASTBinary.php',
	'PytestTestEngine' => 'unit/engine/PytestTestEngine.php',
	'TempFile' => 'filesystem/TempFile.php',
	'TestAbstractDirectedGraph' => 'utils/__tests__/TestAbstractDirectedGraph.php',
	'XHPASTNode' => 'parser/xhpast/api/XHPASTNode.php',
	'XHPASTNodeTestCase' => 'parser/xhpast/api/__tests__/XHPASTNodeTestCase.php',
	'XHPASTSyntaxErrorException' => 'parser/xhpast/api/XHPASTSyntaxErrorException.php',
	'XHPASTToken' => 'parser/xhpast/api/XHPASTToken.php',
	'XHPASTTree' => 'parser/xhpast/api/XHPASTTree.php',
	'XHPASTTreeTestCase' => 'parser/xhpast/api/__tests__/XHPASTTreeTestCase.php',
	'XUnitTestEngine' => 'unit/engine/XUnitTestEngine.php',
	'XUnitTestResultParserTestCase' => 'unit/parser/__tests__/XUnitTestResultParserTestCase.php',
	'XsprintfUnknownConversionException' => 'xsprintf/exception/XsprintfUnknownConversionException.php',
	),
	'function' => array(
	'__phutil_autoload' => 'init/init-library.php',
	'array_fuse' => 'utils/utils.php',
	'array_interleave' => 'utils/utils.php',
	'array_mergev' => 'utils/utils.php',
	'array_select_keys' => 'utils/utils.php',
	'assert_instances_of' => 'utils/utils.php',
	'assert_same_keys' => 'utils/utils.php',
	'assert_stringlike' => 'utils/utils.php',
	'coalesce' => 'utils/utils.php',
	'csprintf' => 'xsprintf/csprintf.php',
	'exec_manual' => 'future/exec/execx.php',
	'execx' => 'future/exec/execx.php',
	+ 'gitsprintf' => 'xsprintf/gitsprintf.php',
	'head' => 'utils/utils.php',
	'head_key' => 'utils/utils.php',
	'hgsprintf' => 'xsprintf/hgsprintf.php',
	'id' => 'utils/utils.php',
	'idx' => 'utils/utils.php',
	'idxv' => 'utils/utils.php',
	'ifilter' => 'utils/utils.php',
	'igroup' => 'utils/utils.php',
	'ipull' => 'utils/utils.php',
	'isort' => 'utils/utils.php',
	'jsprintf' => 'xsprintf/jsprintf.php',
	'last' => 'utils/utils.php',
	'last_key' => 'utils/utils.php',
	'ldap_sprintf' => 'xsprintf/ldapsprintf.php',
	'mfilter' => 'utils/utils.php',
	'mgroup' => 'utils/utils.php',
	'mpull' => 'utils/utils.php',
	'msort' => 'utils/utils.php',
	'msortv' => 'utils/utils.php',
	'msortv_internal' => 'utils/utils.php',
	'msortv_natural' => 'utils/utils.php',
	'newv' => 'utils/utils.php',
	'nonempty' => 'utils/utils.php',
	'phlog' => 'error/phlog.php',
	'pht' => 'internationalization/pht.php',
	'phutil_build_http_querystring' => 'utils/utils.php',
	'phutil_build_http_querystring_from_pairs' => 'utils/utils.php',
	'phutil_censor_credentials' => 'utils/utils.php',
	'phutil_console_confirm' => 'console/format.php',
	'phutil_console_format' => 'console/format.php',
	'phutil_console_get_terminal_width' => 'console/format.php',
	'phutil_console_prompt' => 'console/format.php',
	'phutil_console_require_tty' => 'console/format.php',
	'phutil_console_select' => 'console/format.php',
	'phutil_console_wrap' => 'console/format.php',
	'phutil_count' => 'internationalization/pht.php',
	'phutil_date_format' => 'utils/viewutils.php',
	'phutil_decode_mime_header' => 'utils/utils.php',
	'phutil_deprecated' => 'init/lib/moduleutils.php',
	'phutil_describe_type' => 'utils/utils.php',
	'phutil_encode_log' => 'utils/utils.php',
	'phutil_error_listener_example' => 'error/phlog.php',
	'phutil_escape_uri' => 'utils/utils.php',
	'phutil_escape_uri_path_component' => 'utils/utils.php',
	'phutil_fnmatch' => 'utils/utils.php',
	'phutil_format_bytes' => 'utils/viewutils.php',
	'phutil_format_relative_time' => 'utils/viewutils.php',
	'phutil_format_relative_time_detailed' => 'utils/viewutils.php',
	'phutil_format_units_generic' => 'utils/viewutils.php',
	'phutil_fwrite_nonblocking_stream' => 'utils/utils.php',
	'phutil_get_current_library_name' => 'init/lib/moduleutils.php',
	'phutil_get_library_name_for_root' => 'init/lib/moduleutils.php',
	'phutil_get_library_root' => 'init/lib/moduleutils.php',
	'phutil_get_library_root_for_path' => 'init/lib/moduleutils.php',
	'phutil_get_signal_name' => 'future/exec/execx.php',
	'phutil_get_system_locale' => 'utils/utf8.php',
	'phutil_glue' => 'utils/utils.php',
	'phutil_hashes_are_identical' => 'utils/utils.php',
	'phutil_http_parameter_pair' => 'utils/utils.php',
	'phutil_ini_decode' => 'utils/utils.php',
	'phutil_is_hiphop_runtime' => 'utils/utils.php',
	'phutil_is_interactive' => 'utils/utils.php',
	'phutil_is_natural_list' => 'utils/utils.php',
	'phutil_is_noninteractive' => 'utils/utils.php',
	'phutil_is_system_locale_available' => 'utils/utf8.php',
	'phutil_is_utf8' => 'utils/utf8.php',
	'phutil_is_utf8_slowly' => 'utils/utf8.php',
	'phutil_is_utf8_with_only_bmp_characters' => 'utils/utf8.php',
	'phutil_is_windows' => 'utils/utils.php',
	'phutil_json_decode' => 'utils/utils.php',
	'phutil_json_encode' => 'utils/utils.php',
	'phutil_load_library' => 'init/lib/moduleutils.php',
	'phutil_loggable_string' => 'utils/utils.php',
	'phutil_microseconds_since' => 'utils/utils.php',
	'phutil_parse_bytes' => 'utils/viewutils.php',
	'phutil_partition' => 'utils/utils.php',
	'phutil_passthru' => 'future/exec/execx.php',
	'phutil_person' => 'internationalization/pht.php',
	'phutil_register_library' => 'init/lib/core.php',
	'phutil_register_library_map' => 'init/lib/core.php',
	'phutil_set_system_locale' => 'utils/utf8.php',
	'phutil_split_lines' => 'utils/utils.php',
	'phutil_string_cast' => 'utils/utils.php',
	'phutil_unescape_uri_path_component' => 'utils/utils.php',
	'phutil_units' => 'utils/utils.php',
	'phutil_utf8_console_strlen' => 'utils/utf8.php',
	'phutil_utf8_convert' => 'utils/utf8.php',
	'phutil_utf8_encode_codepoint' => 'utils/utf8.php',
	'phutil_utf8_hard_wrap' => 'utils/utf8.php',
	'phutil_utf8_hard_wrap_html' => 'utils/utf8.php',
	'phutil_utf8_is_cjk' => 'utils/utf8.php',
	'phutil_utf8_is_combining_character' => 'utils/utf8.php',
	'phutil_utf8_strlen' => 'utils/utf8.php',
	'phutil_utf8_strtolower' => 'utils/utf8.php',
	'phutil_utf8_strtoupper' => 'utils/utf8.php',
	'phutil_utf8_strtr' => 'utils/utf8.php',
	'phutil_utf8_ucwords' => 'utils/utf8.php',
	'phutil_utf8ize' => 'utils/utf8.php',
	'phutil_utf8v' => 'utils/utf8.php',
	'phutil_utf8v_codepoints' => 'utils/utf8.php',
	'phutil_utf8v_combine_characters' => 'utils/utf8.php',
	'phutil_utf8v_combined' => 'utils/utf8.php',
	'phutil_validate_json' => 'utils/utils.php',
	'phutil_var_export' => 'utils/utils.php',
	'ppull' => 'utils/utils.php',
	'pregsprintf' => 'xsprintf/pregsprintf.php',
	'tsprintf' => 'xsprintf/tsprintf.php',
	'urisprintf' => 'xsprintf/urisprintf.php',
	'vcsprintf' => 'xsprintf/csprintf.php',
	'vjsprintf' => 'xsprintf/jsprintf.php',
	'vurisprintf' => 'xsprintf/urisprintf.php',
	'xhp_parser_node_constants' => 'parser/xhpast/parser_nodes.php',
	'xhpast_parser_token_constants' => 'parser/xhpast/parser_tokens.php',
	'xsprintf' => 'xsprintf/xsprintf.php',
	'xsprintf_callback_example' => 'xsprintf/xsprintf.php',
	'xsprintf_command' => 'xsprintf/csprintf.php',
	+ 'xsprintf_git' => 'xsprintf/gitsprintf.php',
	'xsprintf_javascript' => 'xsprintf/jsprintf.php',
	'xsprintf_ldap' => 'xsprintf/ldapsprintf.php',
	'xsprintf_mercurial' => 'xsprintf/hgsprintf.php',
	'xsprintf_regex' => 'xsprintf/pregsprintf.php',
	'xsprintf_terminal' => 'xsprintf/tsprintf.php',
	'xsprintf_uri' => 'xsprintf/urisprintf.php',
	),
	'xmap' => array(
	'AASTNode' => 'Phobject',
	'AASTNodeList' => array(
	'Phobject',
	'Countable',
	'Iterator',
	),
	'AASTToken' => 'Phobject',
	'AASTTree' => 'Phobject',
	'AbstractDirectedGraph' => 'Phobject',
	'AbstractDirectedGraphTestCase' => 'PhutilTestCase',
	'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistAlias' => 'Phobject',
	'ArcanistAliasEffect' => 'Phobject',
	'ArcanistAliasEngine' => 'Phobject',
	'ArcanistAliasFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistAliasWorkflow' => 'ArcanistWorkflow',
	'ArcanistAliasesConfigOption' => 'ArcanistMultiSourceConfigOption',
	'ArcanistAmendWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistAnoidWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistArcConfigurationEngineExtension' => 'ArcanistConfigurationEngineExtension',
	'ArcanistArcToolset' => 'ArcanistToolset',
	'ArcanistArcWorkflow' => 'ArcanistWorkflow',
	'ArcanistArrayCombineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistArraySeparatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistArrayValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBaseCommitParser' => 'Phobject',
	'ArcanistBaseCommitParserTestCase' => 'PhutilTestCase',
	'ArcanistBaseXHPASTLinter' => 'ArcanistFutureLinter',
	'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBlindlyTrustHTTPEngineExtension' => 'PhutilHTTPEngineExtension',
	'ArcanistBookmarksWorkflow' => 'ArcanistMarkersWorkflow',
	'ArcanistBoolConfigOption' => 'ArcanistSingleSourceConfigOption',
	'ArcanistBraceFormattingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistBranchesWorkflow' => 'ArcanistMarkersWorkflow',
	'ArcanistBrowseCommitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistBrowseCommitURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
	'ArcanistBrowseObjectNameURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
	'ArcanistBrowsePathURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
	'ArcanistBrowseRef' => 'ArcanistRef',
	'ArcanistBrowseRefInspector' => 'ArcanistRefInspector',
	'ArcanistBrowseRevisionURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
	'ArcanistBrowseURIHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistBrowseURIRef' => 'ArcanistRef',
	'ArcanistBrowseWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistBuildBuildplanHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistBuildPlanRef' => 'ArcanistRef',
	'ArcanistBuildPlanSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistBuildRef' => 'ArcanistRef',
	'ArcanistBuildSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistBuildableBuildsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistBuildableRef' => 'ArcanistRef',
	'ArcanistBuildableSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistBundle' => 'Phobject',
	'ArcanistBundleTestCase' => 'PhutilTestCase',
	'ArcanistCSSLintLinter' => 'ArcanistExternalLinter',
	'ArcanistCSSLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCSharpLinter' => 'ArcanistLinter',
	'ArcanistCallConduitWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistCallParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCapabilityNotSupportedException' => 'Exception',
	'ArcanistCastSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCheckstyleXMLLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistChmodLinter' => 'ArcanistLinter',
	'ArcanistChmodLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistClassExtendsObjectXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistClassNameLiteralXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCloseRevisionWorkflow' => 'ArcanistWorkflow',
	'ArcanistClosureLinter' => 'ArcanistExternalLinter',
	'ArcanistClosureLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCoffeeLintLinter' => 'ArcanistExternalLinter',
	'ArcanistCoffeeLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCommand' => 'Phobject',
	'ArcanistCommentRemover' => 'Phobject',
	'ArcanistCommentRemoverTestCase' => 'PhutilTestCase',
	'ArcanistCommentSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCommentStyleXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCommitGraph' => 'Phobject',
	'ArcanistCommitGraphPartition' => 'Phobject',
	'ArcanistCommitGraphPartitionQuery' => 'Phobject',
	'ArcanistCommitGraphQuery' => 'Phobject',
	'ArcanistCommitGraphSet' => 'Phobject',
	'ArcanistCommitGraphSetQuery' => 'Phobject',
	'ArcanistCommitGraphSetTreeView' => 'Phobject',
	'ArcanistCommitGraphSetView' => 'Phobject',
	'ArcanistCommitGraphTestCase' => 'PhutilTestCase',
	'ArcanistCommitNode' => 'Phobject',
	'ArcanistCommitRef' => 'ArcanistRef',
	'ArcanistCommitSymbolRef' => 'ArcanistSymbolRef',
	'ArcanistCommitSymbolRefInspector' => 'ArcanistRefInspector',
	'ArcanistCommitUpstreamHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
	'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistComposerLinter' => 'ArcanistLinter',
	'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
	'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistConduitAuthenticationException' => 'Exception',
	'ArcanistConduitCallFuture' => 'FutureProxy',
	'ArcanistConduitEngine' => 'Phobject',
	'ArcanistConduitException' => 'Exception',
	'ArcanistConfigOption' => 'Phobject',
	'ArcanistConfiguration' => 'Phobject',
	'ArcanistConfigurationDrivenLintEngine' => 'ArcanistLintEngine',
	'ArcanistConfigurationDrivenUnitTestEngine' => 'ArcanistUnitTestEngine',
	'ArcanistConfigurationEngine' => 'Phobject',
	'ArcanistConfigurationEngineExtension' => 'Phobject',
	'ArcanistConfigurationManager' => 'Phobject',
	'ArcanistConfigurationSource' => 'Phobject',
	'ArcanistConfigurationSourceList' => 'Phobject',
	'ArcanistConfigurationSourceValue' => 'Phobject',
	'ArcanistConsoleLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistConsoleLintRendererTestCase' => 'PhutilTestCase',
	'ArcanistConstructorParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistContinueInsideSwitchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistControlStatementSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistControlStatementSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistCoverWorkflow' => 'ArcanistWorkflow',
	'ArcanistCppcheckLinter' => 'ArcanistExternalLinter',
	'ArcanistCppcheckLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCpplintLinter' => 'ArcanistExternalLinter',
	'ArcanistCpplintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistCurlyBraceArrayIndexXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDeclarationParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDefaultParametersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDefaultParametersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDefaultsConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
	'ArcanistDeprecationXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDictionaryConfigurationSource' => 'ArcanistConfigurationSource',
	'ArcanistDiffByteSizeException' => 'Exception',
	'ArcanistDiffChange' => 'Phobject',
	'ArcanistDiffChangeType' => 'Phobject',
	'ArcanistDiffHunk' => 'Phobject',
	'ArcanistDiffParser' => 'Phobject',
	'ArcanistDiffParserTestCase' => 'PhutilTestCase',
	'ArcanistDiffUtils' => 'Phobject',
	'ArcanistDiffUtilsTestCase' => 'PhutilTestCase',
	'ArcanistDiffVectorNode' => 'Phobject',
	'ArcanistDiffVectorTree' => 'Phobject',
	'ArcanistDiffWorkflow' => 'ArcanistWorkflow',
	'ArcanistDifferentialCommitMessage' => 'Phobject',
	'ArcanistDifferentialCommitMessageParserException' => 'Exception',
	'ArcanistDifferentialDependencyGraph' => 'AbstractDirectedGraph',
	'ArcanistDifferentialRevisionHash' => 'Phobject',
	'ArcanistDifferentialRevisionStatus' => 'Phobject',
	'ArcanistDoubleQuoteXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDownloadWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistDynamicDefineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistElseIfUsageXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistEmptyFileXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistEmptyStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistEventType' => 'PhutilEventType',
	'ArcanistExitExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistExportWorkflow' => 'ArcanistWorkflow',
	'ArcanistExternalLinter' => 'ArcanistFutureLinter',
	'ArcanistExternalLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistExtractUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistFileConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
	'ArcanistFileDataRef' => 'Phobject',
	'ArcanistFileRef' => 'ArcanistRef',
	'ArcanistFileSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistFileUploader' => 'Phobject',
	'ArcanistFilenameLinter' => 'ArcanistLinter',
	'ArcanistFilenameLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistFilesystemAPI' => 'ArcanistRepositoryAPI',
	'ArcanistFilesystemConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
	'ArcanistFilesystemWorkingCopy' => 'ArcanistWorkingCopy',
	'ArcanistFlake8Linter' => 'ArcanistExternalLinter',
	'ArcanistFlake8LinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistFormattedStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistFutureLinter' => 'ArcanistLinter',
	'ArcanistGeneratedLinter' => 'ArcanistLinter',
	'ArcanistGeneratedLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistGetConfigWorkflow' => 'ArcanistWorkflow',
	'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
	'ArcanistGitCommitGraphQuery' => 'ArcanistCommitGraphQuery',
	'ArcanistGitCommitMessageHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
	'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
	'ArcanistGitLandEngine' => 'ArcanistLandEngine',
	'ArcanistGitLocalState' => 'ArcanistRepositoryLocalState',
	'ArcanistGitRawCommit' => 'Phobject',
	'ArcanistGitRawCommitTestCase' => 'PhutilTestCase',
	'ArcanistGitRepositoryMarkerQuery' => 'ArcanistRepositoryMarkerQuery',
	'ArcanistGitRepositoryRemoteQuery' => 'ArcanistRepositoryRemoteQuery',
	'ArcanistGitUpstreamPath' => 'Phobject',
	'ArcanistGitWorkEngine' => 'ArcanistWorkEngine',
	'ArcanistGitWorkingCopy' => 'ArcanistWorkingCopy',
	'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
	'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
	'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
	'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
	'ArcanistGridCell' => 'Phobject',
	'ArcanistGridColumn' => 'Phobject',
	'ArcanistGridRow' => 'Phobject',
	'ArcanistGridView' => 'Phobject',
	'ArcanistHLintLinter' => 'ArcanistExternalLinter',
	'ArcanistHLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistHardpoint' => 'Phobject',
	'ArcanistHardpointEngine' => 'Phobject',
	'ArcanistHardpointFutureList' => 'Phobject',
	'ArcanistHardpointList' => 'Phobject',
	'ArcanistHardpointObject' => 'Phobject',
	'ArcanistHardpointQuery' => 'Phobject',
	'ArcanistHardpointRequest' => 'Phobject',
	'ArcanistHardpointRequestList' => 'Phobject',
	'ArcanistHardpointTask' => 'Phobject',
	'ArcanistHardpointTaskResult' => 'Phobject',
	'ArcanistHelpWorkflow' => 'ArcanistWorkflow',
	'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistHgClientChannel' => 'PhutilProtocolChannel',
	'ArcanistHgProxyClient' => 'Phobject',
	'ArcanistHgProxyServer' => 'Phobject',
	'ArcanistHgServerChannel' => 'PhutilProtocolChannel',
	'ArcanistImplicitConstructorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistImplicitFallthroughXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistImplicitVisibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistImplodeArgumentOrderXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInlineHTMLXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInnerFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInspectWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistInstallCertificateWorkflow' => 'ArcanistWorkflow',
	'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInvalidModifiersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistJSHintLinter' => 'ArcanistExternalLinter',
	'ArcanistJSHintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistJSONLintLinter' => 'ArcanistExternalLinter',
	'ArcanistJSONLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistJSONLinter' => 'ArcanistLinter',
	'ArcanistJSONLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistJscsLinter' => 'ArcanistExternalLinter',
	'ArcanistJscsLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistKeywordCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLandCommit' => 'Phobject',
	'ArcanistLandCommitSet' => 'Phobject',
	'ArcanistLandEngine' => 'ArcanistWorkflowEngine',
	'ArcanistLandPushFailureException' => 'Exception',
	'ArcanistLandSymbol' => 'Phobject',
	'ArcanistLandTarget' => 'Phobject',
	'ArcanistLandWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLesscLinter' => 'ArcanistExternalLinter',
	'ArcanistLesscLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistLiberateWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistLintEngine' => 'Phobject',
	'ArcanistLintMessage' => 'Phobject',
	'ArcanistLintMessageTestCase' => 'PhutilTestCase',
	'ArcanistLintPatcher' => 'Phobject',
	'ArcanistLintRenderer' => 'Phobject',
	'ArcanistLintResult' => 'Phobject',
	'ArcanistLintSeverity' => 'Phobject',
	'ArcanistLintWorkflow' => 'ArcanistWorkflow',
	'ArcanistLinter' => 'Phobject',
	'ArcanistLinterStandard' => 'Phobject',
	'ArcanistLinterStandardTestCase' => 'PhutilTestCase',
	'ArcanistLinterTestCase' => 'PhutilTestCase',
	'ArcanistLintersWorkflow' => 'ArcanistWorkflow',
	'ArcanistListAssignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistListConfigOption' => 'ArcanistSingleSourceConfigOption',
	'ArcanistListWorkflow' => 'ArcanistWorkflow',
	'ArcanistLocalConfigurationSource' => 'ArcanistWorkingCopyConfigurationSource',
	'ArcanistLogEngine' => 'Phobject',
	'ArcanistLogMessage' => 'Phobject',
	'ArcanistLogicalOperatorsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistLookWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistMarkerRef' => 'ArcanistRef',
	'ArcanistMarkersWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
	'ArcanistMercurialCommitGraphQuery' => 'ArcanistCommitGraphQuery',
	'ArcanistMercurialCommitMessageHardpointQuery' => 'ArcanistWorkflowMercurialHardpointQuery',
	'ArcanistMercurialLandEngine' => 'ArcanistLandEngine',
	'ArcanistMercurialLocalState' => 'ArcanistRepositoryLocalState',
	'ArcanistMercurialParser' => 'Phobject',
	'ArcanistMercurialParserTestCase' => 'PhutilTestCase',
	'ArcanistMercurialRepositoryMarkerQuery' => 'ArcanistRepositoryMarkerQuery',
	'ArcanistMercurialRepositoryRemoteQuery' => 'ArcanistRepositoryRemoteQuery',
	'ArcanistMercurialWorkEngine' => 'ArcanistWorkEngine',
	'ArcanistMercurialWorkingCopy' => 'ArcanistWorkingCopy',
	'ArcanistMercurialWorkingCopyRevisionHardpointQuery' => 'ArcanistWorkflowMercurialHardpointQuery',
	'ArcanistMergeConflictLinter' => 'ArcanistLinter',
	'ArcanistMergeConflictLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistMessageRevisionHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistMissingArgumentTerminatorException' => 'Exception',
	'ArcanistMissingLinterException' => 'Exception',
	'ArcanistModifierOrderingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistMultiSourceConfigOption' => 'ArcanistConfigOption',
	'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistNamingConventionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistNestedNamespacesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistNoEffectException' => 'ArcanistUsageException',
	'ArcanistNoEngineException' => 'ArcanistUsageException',
	'ArcanistNoLintLinter' => 'ArcanistLinter',
	'ArcanistNoLintLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistNoParentScopeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistNoURIConduitException' => 'ArcanistConduitException',
	'ArcanistNoneLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistObjectListHardpoint' => 'ArcanistHardpoint',
	'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPEP8Linter' => 'ArcanistExternalLinter',
	'ArcanistPEP8LinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPHPCloseTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPHPCloseTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPHPCompatibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPHPCompatibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPHPEchoTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPHPEchoTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPHPOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPHPOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPHPShortTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPHPShortTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistParentMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistParentMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistParenthesesSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistParenthesesSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistParseStrUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistParseStrUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPasteRef' => 'ArcanistRef',
	'ArcanistPasteSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistPasteWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistPatchWorkflow' => 'ArcanistWorkflow',
	'ArcanistPhpLinter' => 'ArcanistExternalLinter',
	'ArcanistPhpLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPhpcsLinter' => 'ArcanistExternalLinter',
	'ArcanistPhpcsLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPhpunitTestResultParser' => 'ArcanistTestResultParser',
	'ArcanistPhutilLibraryLinter' => 'ArcanistLinter',
	'ArcanistPhutilWorkflow' => 'PhutilArgumentWorkflow',
	'ArcanistPhutilXHPASTLinterStandard' => 'ArcanistLinterStandard',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistProjectConfigurationSource' => 'ArcanistWorkingCopyConfigurationSource',
	'ArcanistPrompt' => 'Phobject',
	'ArcanistPromptResponse' => 'Phobject',
	'ArcanistPromptsConfigOption' => 'ArcanistMultiSourceConfigOption',
	'ArcanistPromptsWorkflow' => 'ArcanistWorkflow',
	'ArcanistPublicPropertyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistPuppetLintLinter' => 'ArcanistExternalLinter',
	'ArcanistPuppetLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPyFlakesLinter' => 'ArcanistExternalLinter',
	'ArcanistPyFlakesLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistPyLintLinter' => 'ArcanistExternalLinter',
	'ArcanistPyLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistRef' => 'ArcanistHardpointObject',
	'ArcanistRefInspector' => 'Phobject',
	'ArcanistRefView' => array(
	'Phobject',
	'ArcanistTerminalStringInterface',
	),
	'ArcanistRemoteRef' => 'ArcanistRef',
	'ArcanistRemoteRefInspector' => 'ArcanistRefInspector',
	'ArcanistRemoteRepositoryRefsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistRepositoryAPI' => 'Phobject',
	'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
	'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
	'ArcanistRepositoryLocalState' => 'Phobject',
	'ArcanistRepositoryMarkerQuery' => 'ArcanistRepositoryQuery',
	'ArcanistRepositoryQuery' => 'Phobject',
	'ArcanistRepositoryRef' => 'ArcanistRef',
	'ArcanistRepositoryRemoteQuery' => 'ArcanistRepositoryQuery',
	'ArcanistRepositoryURINormalizer' => 'Phobject',
	'ArcanistRepositoryURINormalizerTestCase' => 'PhutilTestCase',
	'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistRevisionAuthorHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistRevisionBuildableHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistRevisionCommitMessageHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistRevisionParentRevisionsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistRevisionRef' => 'ArcanistRef',
	'ArcanistRevisionRefSource' => 'Phobject',
	'ArcanistRevisionSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistRuboCopLinter' => 'ArcanistExternalLinter',
	'ArcanistRuboCopLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistRubyLinter' => 'ArcanistExternalLinter',
	'ArcanistRubyLinterTestCase' => 'ArcanistExternalLinterTestCase',
	'ArcanistRuntimeConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
	'ArcanistRuntimeHardpointQuery' => 'ArcanistHardpointQuery',
	'ArcanistScalarHardpoint' => 'ArcanistHardpoint',
	'ArcanistScriptAndRegexLinter' => 'ArcanistLinter',
	'ArcanistSelfClassReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSemicolonSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSetConfigWorkflow' => 'ArcanistWorkflow',
	'ArcanistSetting' => 'Phobject',
	'ArcanistSettings' => 'Phobject',
	'ArcanistShellCompleteWorkflow' => 'ArcanistWorkflow',
	'ArcanistSimpleCommitGraphQuery' => 'ArcanistCommitGraphQuery',
	'ArcanistSimpleSymbolHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistSimpleSymbolRef' => 'ArcanistSymbolRef',
	'ArcanistSimpleSymbolRefInspector' => 'ArcanistRefInspector',
	'ArcanistSingleLintEngine' => 'ArcanistLintEngine',
	'ArcanistSingleSourceConfigOption' => 'ArcanistConfigOption',
	'ArcanistSlownessXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSlownessXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistSpellingLinter' => 'ArcanistLinter',
	'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistStaticThisXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistStringConfigOption' => 'ArcanistSingleSourceConfigOption',
	'ArcanistStringListConfigOption' => 'ArcanistListConfigOption',
	'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
	'ArcanistSubversionWorkingCopy' => 'ArcanistWorkingCopy',
	'ArcanistSummaryLintRenderer' => 'ArcanistLintRenderer',
	'ArcanistSymbolEngine' => 'Phobject',
	'ArcanistSymbolRef' => 'ArcanistRef',
	'ArcanistSyntaxErrorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistSystemConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
	'ArcanistTaskRef' => 'ArcanistRef',
	'ArcanistTaskSymbolRef' => 'ArcanistSimpleSymbolRef',
	'ArcanistTasksWorkflow' => 'ArcanistWorkflow',
	'ArcanistTautologicalExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTestResultParser' => 'Phobject',
	'ArcanistTestXHPASTLintSwitchHook' => 'ArcanistXHPASTLintSwitchHook',
	'ArcanistTextLinter' => 'ArcanistLinter',
	'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistThisReassignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistToStringExceptionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTodoCommentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistTodoWorkflow' => 'ArcanistWorkflow',
	'ArcanistToolset' => 'Phobject',
	'ArcanistUSEnglishTranslation' => 'PhutilTranslation',
	'ArcanistUnableToParseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUndeclaredVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUnitConsoleRenderer' => 'ArcanistUnitRenderer',
	'ArcanistUnitRenderer' => 'Phobject',
	'ArcanistUnitTestEngine' => 'Phobject',
	'ArcanistUnitTestResult' => 'Phobject',
	'ArcanistUnitTestResultTestCase' => 'PhutilTestCase',
	'ArcanistUnitTestableLintEngine' => 'ArcanistLintEngine',
	'ArcanistUnitWorkflow' => 'ArcanistWorkflow',
	'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUpgradeWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistUploadWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistUsageException' => 'Exception',
	'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistUserAbortException' => 'ArcanistUsageException',
	'ArcanistUserConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
	'ArcanistUserRef' => 'ArcanistRef',
	'ArcanistUserSymbolHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistUserSymbolRef' => 'ArcanistSymbolRef',
	'ArcanistUserSymbolRefInspector' => 'ArcanistRefInspector',
	'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistVariableVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
	'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
	'ArcanistVectorHardpoint' => 'ArcanistHardpoint',
	'ArcanistVersionWorkflow' => 'ArcanistWorkflow',
	'ArcanistWeldWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistWhichWorkflow' => 'ArcanistWorkflow',
	'ArcanistWildConfigOption' => 'ArcanistConfigOption',
	'ArcanistWorkEngine' => 'ArcanistWorkflowEngine',
	'ArcanistWorkWorkflow' => 'ArcanistArcWorkflow',
	'ArcanistWorkflow' => 'Phobject',
	'ArcanistWorkflowArgument' => 'Phobject',
	'ArcanistWorkflowEngine' => 'Phobject',
	'ArcanistWorkflowGitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistWorkflowInformation' => 'Phobject',
	'ArcanistWorkflowMercurialHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
	'ArcanistWorkingCopy' => 'Phobject',
	'ArcanistWorkingCopyConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
	'ArcanistWorkingCopyIdentity' => 'Phobject',
	'ArcanistWorkingCopyPath' => 'Phobject',
	'ArcanistWorkingCopyStateRef' => 'ArcanistRef',
	'ArcanistWorkingCopyStateRefInspector' => 'ArcanistRefInspector',
	'ArcanistXHPASTLintNamingHook' => 'Phobject',
	'ArcanistXHPASTLintNamingHookTestCase' => 'PhutilTestCase',
	'ArcanistXHPASTLintSwitchHook' => 'Phobject',
	'ArcanistXHPASTLinter' => 'ArcanistBaseXHPASTLinter',
	'ArcanistXHPASTLinterRule' => 'Phobject',
	'ArcanistXHPASTLinterRuleTestCase' => 'ArcanistLinterTestCase',
	'ArcanistXHPASTLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistXMLLinter' => 'ArcanistLinter',
	'ArcanistXMLLinterTestCase' => 'ArcanistLinterTestCase',
	'ArcanistXUnitTestResultParser' => 'Phobject',
	'BaseHTTPFuture' => 'Future',
	'CSharpToolsTestEngine' => 'XUnitTestEngine',
	'CaseInsensitiveArray' => 'PhutilArray',
	'CaseInsensitiveArrayTestCase' => 'PhutilTestCase',
	'CommandException' => 'Exception',
	'ConduitClient' => 'Phobject',
	'ConduitClientException' => 'Exception',
	'ConduitClientTestCase' => 'PhutilTestCase',
	'ConduitFuture' => 'FutureProxy',
	'ConduitSearchFuture' => 'FutureAgent',
	'ExecFuture' => 'PhutilExecutableFuture',
	'ExecFutureTestCase' => 'PhutilTestCase',
	'ExecPassthruTestCase' => 'PhutilTestCase',
	'FileFinder' => 'Phobject',
	'FileFinderTestCase' => 'PhutilTestCase',
	'FileList' => 'Phobject',
	'Filesystem' => 'Phobject',
	'FilesystemException' => 'Exception',
	'FilesystemTestCase' => 'PhutilTestCase',
	'Future' => 'Phobject',
	'FutureAgent' => 'Future',
	'FutureIterator' => array(
	'Phobject',
	'Iterator',
	),
	'FutureIteratorTestCase' => 'PhutilTestCase',
	'FuturePool' => 'Phobject',
	'FutureProxy' => 'Future',
	'HTTPFuture' => 'BaseHTTPFuture',
	'HTTPFutureCURLResponseStatus' => 'HTTPFutureResponseStatus',
	'HTTPFutureCertificateResponseStatus' => 'HTTPFutureResponseStatus',
	'HTTPFutureHTTPResponseStatus' => 'HTTPFutureResponseStatus',
	'HTTPFutureParseResponseStatus' => 'HTTPFutureResponseStatus',
	'HTTPFutureResponseStatus' => 'Exception',
	'HTTPFutureTransportResponseStatus' => 'HTTPFutureResponseStatus',
	'HTTPSFuture' => 'BaseHTTPFuture',
	'ImmediateFuture' => 'Future',
	'LibphutilUSEnglishTranslation' => 'PhutilTranslation',
	'LinesOfALarge' => array(
	'Phobject',
	'Iterator',
	),
	'LinesOfALargeExecFuture' => 'LinesOfALarge',
	'LinesOfALargeExecFutureTestCase' => 'PhutilTestCase',
	'LinesOfALargeFile' => 'LinesOfALarge',
	'LinesOfALargeFileTestCase' => 'PhutilTestCase',
	'MFilterTestHelper' => 'Phobject',
	'NoseTestEngine' => 'ArcanistUnitTestEngine',
	'PHPASTParserTestCase' => 'PhutilTestCase',
	'PhageAction' => 'Phobject',
	'PhageAgentAction' => 'PhageAction',
	'PhageAgentBootloader' => 'Phobject',
	'PhageAgentTestCase' => 'PhutilTestCase',
	'PhageExecWorkflow' => 'PhageWorkflow',
	'PhageExecuteAction' => 'PhageAction',
	'PhageLocalAction' => 'PhageAgentAction',
	'PhagePHPAgent' => 'Phobject',
	'PhagePHPAgentBootloader' => 'PhageAgentBootloader',
	'PhagePlanAction' => 'PhageAction',
	'PhageToolset' => 'ArcanistToolset',
	'PhageWorkflow' => 'ArcanistWorkflow',
	'Phobject' => 'Iterator',
	'PhobjectTestCase' => 'PhutilTestCase',
	'PhpunitTestEngine' => 'ArcanistUnitTestEngine',
	'PhpunitTestEngineTestCase' => 'PhutilTestCase',
	'PhutilAWSCloudFormationFuture' => 'PhutilAWSFuture',
	'PhutilAWSCloudWatchFuture' => 'PhutilAWSFuture',
	'PhutilAWSEC2Future' => 'PhutilAWSFuture',
	'PhutilAWSException' => 'Exception',
	'PhutilAWSFuture' => 'FutureProxy',
	'PhutilAWSManagementWorkflow' => 'PhutilArgumentWorkflow',
	'PhutilAWSS3DeleteManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
	'PhutilAWSS3Future' => 'PhutilAWSFuture',
	'PhutilAWSS3GetManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
	'PhutilAWSS3ManagementWorkflow' => 'PhutilAWSManagementWorkflow',
	'PhutilAWSS3PutManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
	'PhutilAWSv4Signature' => 'Phobject',
	'PhutilAWSv4SignatureTestCase' => 'PhutilTestCase',
	'PhutilAggregateException' => 'Exception',
	'PhutilAllCapsEnglishLocale' => 'PhutilLocale',
	'PhutilArgumentParser' => 'Phobject',
	'PhutilArgumentParserException' => 'Exception',
	'PhutilArgumentParserTestCase' => 'PhutilTestCase',
	'PhutilArgumentSpecification' => 'Phobject',
	'PhutilArgumentSpecificationException' => 'PhutilArgumentParserException',
	'PhutilArgumentSpecificationTestCase' => 'PhutilTestCase',
	'PhutilArgumentSpellingCorrector' => 'Phobject',
	'PhutilArgumentSpellingCorrectorTestCase' => 'PhutilTestCase',
	'PhutilArgumentUsageException' => 'PhutilArgumentParserException',
	'PhutilArgumentWorkflow' => 'Phobject',
	'PhutilArray' => array(
	'Phobject',
	'Countable',
	'ArrayAccess',
	'Iterator',
	),
	'PhutilArrayCheck' => 'Phobject',
	'PhutilArrayTestCase' => 'PhutilTestCase',
	'PhutilArrayWithDefaultValue' => 'PhutilArray',
	'PhutilAsanaFuture' => 'FutureProxy',
	'PhutilBacktraceSignalHandler' => 'PhutilSignalHandler',
	'PhutilBallOfPHP' => 'Phobject',
	'PhutilBinaryAnalyzer' => 'Phobject',
	'PhutilBinaryAnalyzerTestCase' => 'PhutilTestCase',
	'PhutilBootloaderException' => 'Exception',
	'PhutilBritishEnglishLocale' => 'PhutilLocale',
	'PhutilBufferedIterator' => array(
	'Phobject',
	'Iterator',
	),
	'PhutilBufferedIteratorTestCase' => 'PhutilTestCase',
	'PhutilBugtraqParser' => 'Phobject',
	'PhutilBugtraqParserTestCase' => 'PhutilTestCase',
	'PhutilCIDRBlock' => 'Phobject',
	'PhutilCIDRList' => 'Phobject',
	'PhutilCallbackFilterIterator' => 'FilterIterator',
	'PhutilCallbackSignalHandler' => 'PhutilSignalHandler',
	'PhutilChannel' => 'Phobject',
	'PhutilChannelChannel' => 'PhutilChannel',
	'PhutilChannelTestCase' => 'PhutilTestCase',
	'PhutilChunkedIterator' => array(
	'Phobject',
	'Iterator',
	),
	'PhutilChunkedIteratorTestCase' => 'PhutilTestCase',
	'PhutilClassMapQuery' => 'Phobject',
	'PhutilCloudWatchMetric' => 'Phobject',
	'PhutilCommandString' => 'Phobject',
	'PhutilConsole' => 'Phobject',
	'PhutilConsoleBlock' => 'PhutilConsoleView',
	'PhutilConsoleError' => 'PhutilConsoleLogLine',
	'PhutilConsoleFormatter' => 'Phobject',
	'PhutilConsoleInfo' => 'PhutilConsoleLogLine',
	'PhutilConsoleList' => 'PhutilConsoleView',
	'PhutilConsoleLogLine' => 'PhutilConsoleView',
	'PhutilConsoleMessage' => 'Phobject',
	'PhutilConsoleMetrics' => 'Phobject',
	'PhutilConsoleMetricsSignalHandler' => 'PhutilSignalHandler',
	'PhutilConsoleProgressBar' => 'Phobject',
	'PhutilConsoleProgressSink' => 'PhutilProgressSink',
	'PhutilConsoleServer' => 'Phobject',
	'PhutilConsoleServerChannel' => 'PhutilChannelChannel',
	'PhutilConsoleSkip' => 'PhutilConsoleLogLine',
	'PhutilConsoleStdinNotInteractiveException' => 'Exception',
	'PhutilConsoleTable' => 'PhutilConsoleView',
	'PhutilConsoleView' => 'Phobject',
	'PhutilConsoleWarning' => 'PhutilConsoleLogLine',
	'PhutilConsoleWrapTestCase' => 'PhutilTestCase',
	'PhutilCowsay' => 'Phobject',
	'PhutilCowsayTestCase' => 'PhutilTestCase',
	'PhutilCsprintfTestCase' => 'PhutilTestCase',
	'PhutilCzechLocale' => 'PhutilLocale',
	'PhutilDOMNode' => 'Phobject',
	'PhutilDeferredLog' => 'Phobject',
	'PhutilDeferredLogTestCase' => 'PhutilTestCase',
	'PhutilDiffBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
	'PhutilDirectedScalarGraph' => 'AbstractDirectedGraph',
	'PhutilDirectoryFixture' => 'Phobject',
	'PhutilDocblockParser' => 'Phobject',
	'PhutilDocblockParserTestCase' => 'PhutilTestCase',
	'PhutilEditDistanceMatrix' => 'Phobject',
	'PhutilEditDistanceMatrixTestCase' => 'PhutilTestCase',
	'PhutilEditorConfig' => 'Phobject',
	'PhutilEditorConfigTestCase' => 'PhutilTestCase',
	'PhutilEmailAddress' => 'Phobject',
	'PhutilEmailAddressTestCase' => 'PhutilTestCase',
	'PhutilEmojiLocale' => 'PhutilLocale',
	'PhutilEnglishCanadaLocale' => 'PhutilLocale',
	'PhutilErrorHandler' => 'Phobject',
	'PhutilErrorHandlerTestCase' => 'PhutilTestCase',
	'PhutilErrorTrap' => 'Phobject',
	'PhutilEvent' => 'Phobject',
	'PhutilEventConstants' => 'Phobject',
	'PhutilEventEngine' => 'Phobject',
	'PhutilEventListener' => 'Phobject',
	'PhutilEventType' => 'PhutilEventConstants',
	'PhutilExampleBufferedIterator' => 'PhutilBufferedIterator',
	'PhutilExecChannel' => 'PhutilChannel',
	'PhutilExecPassthru' => 'PhutilExecutableFuture',
	'PhutilExecutableFuture' => 'Future',
	'PhutilExecutionEnvironment' => 'Phobject',
	'PhutilFileLock' => 'PhutilLock',
	'PhutilFileLockTestCase' => 'PhutilTestCase',
	'PhutilFrenchLocale' => 'PhutilLocale',
	'PhutilGermanLocale' => 'PhutilLocale',
	'PhutilGitBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
	'PhutilGitHubFuture' => 'FutureProxy',
	'PhutilGitHubResponse' => 'Phobject',
	'PhutilGitURI' => 'Phobject',
	'PhutilGitURITestCase' => 'PhutilTestCase',
	+ 'PhutilGitsprintfTestCase' => 'PhutilTestCase',
	'PhutilHTMLParser' => 'Phobject',
	'PhutilHTMLParserTestCase' => 'PhutilTestCase',
	'PhutilHTTPEngineExtension' => 'Phobject',
	'PhutilHTTPResponse' => 'Phobject',
	'PhutilHTTPResponseParser' => 'Phobject',
	'PhutilHTTPResponseParserTestCase' => 'PhutilTestCase',
	'PhutilHashingIterator' => array(
	'PhutilProxyIterator',
	'Iterator',
	),
	'PhutilHashingIteratorTestCase' => 'PhutilTestCase',
	'PhutilHelpArgumentWorkflow' => 'PhutilArgumentWorkflow',
	'PhutilHgsprintfTestCase' => 'PhutilTestCase',
	'PhutilINIParserException' => 'Exception',
	'PhutilIPAddress' => 'Phobject',
	'PhutilIPAddressTestCase' => 'PhutilTestCase',
	'PhutilIPv4Address' => 'PhutilIPAddress',
	'PhutilIPv6Address' => 'PhutilIPAddress',
	'PhutilInteractiveEditor' => 'Phobject',
	'PhutilInvalidRuleParserGeneratorException' => 'PhutilParserGeneratorException',
	'PhutilInvalidStateException' => 'Exception',
	'PhutilInvalidStateExceptionTestCase' => 'PhutilTestCase',
	'PhutilIrreducibleRuleParserGeneratorException' => 'PhutilParserGeneratorException',
	'PhutilJSON' => 'Phobject',
	'PhutilJSONFragmentLexer' => 'PhutilLexer',
	'PhutilJSONParser' => 'Phobject',
	'PhutilJSONParserException' => 'Exception',
	'PhutilJSONParserTestCase' => 'PhutilTestCase',
	'PhutilJSONProtocolChannel' => 'PhutilProtocolChannel',
	'PhutilJSONProtocolChannelTestCase' => 'PhutilTestCase',
	'PhutilJSONTestCase' => 'PhutilTestCase',
	'PhutilJavaFragmentLexer' => 'PhutilLexer',
	'PhutilKoreanLocale' => 'PhutilLocale',
	'PhutilLanguageGuesser' => 'Phobject',
	'PhutilLanguageGuesserTestCase' => 'PhutilTestCase',
	'PhutilLexer' => 'Phobject',
	'PhutilLibraryConflictException' => 'Exception',
	'PhutilLibraryMapBuilder' => 'Phobject',
	'PhutilLibraryTestCase' => 'PhutilTestCase',
	'PhutilLocale' => 'Phobject',
	'PhutilLocaleTestCase' => 'PhutilTestCase',
	'PhutilLock' => 'Phobject',
	'PhutilLockException' => 'Exception',
	'PhutilLogFileChannel' => 'PhutilChannelChannel',
	'PhutilLunarPhase' => 'Phobject',
	'PhutilLunarPhaseTestCase' => 'PhutilTestCase',
	'PhutilMercurialBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
	'PhutilMethodNotImplementedException' => 'Exception',
	'PhutilMetricsChannel' => 'PhutilChannelChannel',
	'PhutilMissingSymbolException' => 'Exception',
	'PhutilModuleUtilsTestCase' => 'PhutilTestCase',
	'PhutilNumber' => 'Phobject',
	'PhutilOAuth1Future' => 'FutureProxy',
	'PhutilOAuth1FutureTestCase' => 'PhutilTestCase',
	'PhutilOpaqueEnvelope' => 'Phobject',
	'PhutilOpaqueEnvelopeKey' => 'Phobject',
	'PhutilOpaqueEnvelopeTestCase' => 'PhutilTestCase',
	'PhutilPHPFragmentLexer' => 'PhutilLexer',
	'PhutilPHPFragmentLexerTestCase' => 'PhutilTestCase',
	'PhutilPHPObjectProtocolChannel' => 'PhutilProtocolChannel',
	'PhutilPHPObjectProtocolChannelTestCase' => 'PhutilTestCase',
	'PhutilParserGenerator' => 'Phobject',
	'PhutilParserGeneratorException' => 'Exception',
	'PhutilParserGeneratorTestCase' => 'PhutilTestCase',
	'PhutilPayPalAPIFuture' => 'FutureProxy',
	'PhutilPersonTest' => array(
	'Phobject',
	'PhutilPerson',
	),
	'PhutilPhtTestCase' => 'PhutilTestCase',
	'PhutilPirateEnglishLocale' => 'PhutilLocale',
	'PhutilPortugueseBrazilLocale' => 'PhutilLocale',
	'PhutilPortuguesePortugalLocale' => 'PhutilLocale',
	'PhutilPostmarkFuture' => 'FutureProxy',
	'PhutilPregsprintfTestCase' => 'PhutilTestCase',
	'PhutilProcessQuery' => 'Phobject',
	'PhutilProcessRef' => 'Phobject',
	'PhutilProcessRefTestCase' => 'PhutilTestCase',
	'PhutilProgressSink' => 'Phobject',
	'PhutilProtocolChannel' => 'PhutilChannelChannel',
	'PhutilProxyException' => 'Exception',
	'PhutilProxyIterator' => array(
	'Phobject',
	'Iterator',
	),
	'PhutilPygmentizeBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
	'PhutilPythonFragmentLexer' => 'PhutilLexer',
	'PhutilQueryStringParser' => 'Phobject',
	'PhutilQueryStringParserTestCase' => 'PhutilTestCase',
	'PhutilRawEnglishLocale' => 'PhutilLocale',
	'PhutilReadableSerializer' => 'Phobject',
	'PhutilReadableSerializerTestCase' => 'PhutilTestCase',
	'PhutilRope' => 'Phobject',
	'PhutilRopeTestCase' => 'PhutilTestCase',
	'PhutilServiceProfiler' => 'Phobject',
	'PhutilShellLexer' => 'PhutilLexer',
	'PhutilShellLexerTestCase' => 'PhutilTestCase',
	'PhutilSignalHandler' => 'Phobject',
	'PhutilSignalRouter' => 'Phobject',
	'PhutilSimpleOptions' => 'Phobject',
	'PhutilSimpleOptionsLexer' => 'PhutilLexer',
	'PhutilSimpleOptionsLexerTestCase' => 'PhutilTestCase',
	'PhutilSimpleOptionsTestCase' => 'PhutilTestCase',
	'PhutilSimplifiedChineseLocale' => 'PhutilLocale',
	'PhutilSlackFuture' => 'FutureProxy',
	'PhutilSocketChannel' => 'PhutilChannel',
	'PhutilSortVector' => 'Phobject',
	'PhutilSpanishSpainLocale' => 'PhutilLocale',
	'PhutilStreamIterator' => array(
	'Phobject',
	'Iterator',
	),
	'PhutilSubversionBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
	'PhutilSystem' => 'Phobject',
	'PhutilSystemTestCase' => 'PhutilTestCase',
	'PhutilTerminalString' => 'Phobject',
	'PhutilTestCase' => 'Phobject',
	'PhutilTestCaseTestCase' => 'PhutilTestCase',
	'PhutilTestPhobject' => 'Phobject',
	'PhutilTestSkippedException' => 'Exception',
	'PhutilTestTerminatedException' => 'Exception',
	'PhutilTraditionalChineseLocale' => 'PhutilLocale',
	'PhutilTranslation' => 'Phobject',
	'PhutilTranslationTestCase' => 'PhutilTestCase',
	'PhutilTranslator' => 'Phobject',
	'PhutilTranslatorTestCase' => 'PhutilTestCase',
	'PhutilTsprintfTestCase' => 'PhutilTestCase',
	'PhutilTwitchFuture' => 'FutureProxy',
	'PhutilTypeCheckException' => 'Exception',
	'PhutilTypeExtraParametersException' => 'Exception',
	'PhutilTypeLexer' => 'PhutilLexer',
	'PhutilTypeMissingParametersException' => 'Exception',
	'PhutilTypeSpec' => 'Phobject',
	'PhutilTypeSpecTestCase' => 'PhutilTestCase',
	'PhutilURI' => 'Phobject',
	'PhutilURITestCase' => 'PhutilTestCase',
	'PhutilUSEnglishLocale' => 'PhutilLocale',
	'PhutilUTF8StringTruncator' => 'Phobject',
	'PhutilUTF8TestCase' => 'PhutilTestCase',
	'PhutilUnitTestEngine' => 'ArcanistUnitTestEngine',
	'PhutilUnitTestEngineTestCase' => 'PhutilTestCase',
	'PhutilUnknownSymbolParserGeneratorException' => 'PhutilParserGeneratorException',
	'PhutilUnreachableRuleParserGeneratorException' => 'PhutilParserGeneratorException',
	'PhutilUnreachableTerminalParserGeneratorException' => 'PhutilParserGeneratorException',
	'PhutilUrisprintfTestCase' => 'PhutilTestCase',
	'PhutilUtilsTestCase' => 'PhutilTestCase',
	'PhutilVeryWowEnglishLocale' => 'PhutilLocale',
	'PhutilWordPressFuture' => 'FutureProxy',
	'PhutilXHPASTBinary' => 'Phobject',
	'PytestTestEngine' => 'ArcanistUnitTestEngine',
	'TempFile' => 'Phobject',
	'TestAbstractDirectedGraph' => 'AbstractDirectedGraph',
	'XHPASTNode' => 'AASTNode',
	'XHPASTNodeTestCase' => 'PhutilTestCase',
	'XHPASTSyntaxErrorException' => 'Exception',
	'XHPASTToken' => 'AASTToken',
	'XHPASTTree' => 'AASTTree',
	'XHPASTTreeTestCase' => 'PhutilTestCase',
	'XUnitTestEngine' => 'ArcanistUnitTestEngine',
	'XUnitTestResultParserTestCase' => 'PhutilTestCase',
	'XsprintfUnknownConversionException' => 'InvalidArgumentException',
	),
	));
	diff --git a/src/land/engine/ArcanistGitLandEngine.php b/src/land/engine/ArcanistGitLandEngine.php
	index 76cce096..47161b27 100644
	--- a/src/land/engine/ArcanistGitLandEngine.php
	+++ b/src/land/engine/ArcanistGitLandEngine.php
	@@ -1,1602 +1,1604 @@
	<?php

	final class ArcanistGitLandEngine
	extends ArcanistLandEngine {

	private $isGitPerforce;
	private $landTargetCommitMap = array();
	private $deletedBranches = array();

	private function setIsGitPerforce($is_git_perforce) {
	$this->isGitPerforce = $is_git_perforce;
	return $this;
	}

	private function getIsGitPerforce() {
	return $this->isGitPerforce;
	}

	protected function pruneBranches(array $sets) {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	$old_commits = array();
	foreach ($sets as $set) {
	$hash = last($set->getCommits())->getHash();
	$old_commits[] = $hash;
	}

	$branch_map = $this->getBranchesForCommits(
	$old_commits,
	$is_contains = false);

	foreach ($branch_map as $branch_name => $branch_hash) {
	$recovery_command = csprintf(
	'git checkout -b %s %s',
	$branch_name,
	$api->getDisplayHash($branch_hash));

	$log->writeStatus(
	pht('CLEANUP'),
	pht('Cleaning up branch "%s". To recover, run:', $branch_name));

	echo tsprintf(
	"\n $ %s\n\n",
	$recovery_command);

	$api->execxLocal('branch -D -- %s', $branch_name);
	$this->deletedBranches[$branch_name] = true;
	}
	}

	private function getBranchesForCommits(array $hashes, $is_contains) {
	$api = $this->getRepositoryAPI();

	$format = '%(refname) %(objectname)';

	$result = array();
	foreach ($hashes as $hash) {
	if ($is_contains) {
	$command = csprintf(
	'for-each-ref --contains %s --format %s --',
	$hash,
	$format);
	} else {
	$command = csprintf(
	'for-each-ref --points-at %s --format %s --',
	$hash,
	$format);
	}

	list($foreach_lines) = $api->execxLocal('%C', $command);
	$foreach_lines = phutil_split_lines($foreach_lines, false);

	foreach ($foreach_lines as $line) {
	if (!strlen($line)) {
	continue;
	}

	$expect_parts = 2;
	$parts = explode(' ', $line, $expect_parts);
	if (count($parts) !== $expect_parts) {
	throw new Exception(
	pht(
	'Failed to explode line "%s".',
	$line));
	}

	$ref_name = $parts[0];
	$ref_hash = $parts[1];

	$matches = null;
	$ok = preg_match('(^refs/heads/(.*)\z)', $ref_name, $matches);
	if ($ok === false) {
	throw new Exception(
	pht(
	'Failed to match against branch pattern "%s".',
	$line));
	}

	if (!$ok) {
	continue;
	}

	$result[$matches[1]] = $ref_hash;
	}
	}

	// Sort the result so that branches are processed in natural order.
	$names = array_keys($result);
	natcasesort($names);
	$result = array_select_keys($result, $names);

	return $result;
	}

	protected function cascadeState(ArcanistLandCommitSet $set, $into_commit) {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	// This has no effect when we're executing a merge strategy.
	if (!$this->isSquashStrategy()) {
	return;
	}

	$min_commit = head($set->getCommits())->getHash();
	$old_commit = last($set->getCommits())->getHash();
	$new_commit = $into_commit;

	$branch_map = $this->getBranchesForCommits(
	array($old_commit),
	$is_contains = true);

	$log = $this->getLogEngine();
	foreach ($branch_map as $branch_name => $branch_head) {
	// If this branch just points at the old state, don't bother rebasing
	// it. We'll update or delete it later.
	if ($branch_head === $old_commit) {
	continue;
	}

	$log->writeStatus(
	pht('CASCADE'),
	pht(
	'Rebasing "%s" onto landed state...',
	$branch_name));

	// If we used "--pick" to select this commit, we want to rebase branches
	// that descend from it onto its ancestor, not onto the landed change.

	// For example, if the change sequence was "W", "X", "Y", "Z" and we
	// landed "Y" onto "master" using "--pick", we want to rebase "Z" onto
	// "X" (so "W" and "X", which it will often depend on, are still
	// its ancestors), not onto the new "master".

	if ($set->getIsPick()) {
	$rebase_target = $min_commit.'^';
	} else {
	$rebase_target = $new_commit;
	}

	try {
	$api->execxLocal(
	'rebase --onto %s -- %s %s',
	$rebase_target,
	$old_commit,
	$branch_name);
	} catch (CommandException $ex) {
	$api->execManualLocal('rebase --abort');
	$api->execManualLocal('reset --hard HEAD --');

	$log->writeWarning(
	pht('REBASE CONFLICT'),
	pht(
	'Branch "%s" does not rebase cleanly from "%s" onto '.
	'"%s", skipping.',
	$branch_name,
	$api->getDisplayHash($old_commit),
	$api->getDisplayHash($rebase_target)));
	}
	}
	}

	private function fetchTarget(ArcanistLandTarget $target) {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	// NOTE: Although this output isn't hugely useful, we need to passthru
	// instead of using a subprocess here because `git fetch` may prompt the
	// user to enter a password if they're fetching over HTTP with basic
	// authentication. See T10314.

	if ($this->getIsGitPerforce()) {
	$log->writeStatus(
	pht('P4 SYNC'),
	pht(
	'Synchronizing "%s" from Perforce...',
	$target->getRef()));

	$err = $this->newPassthru(
	'p4 sync --silent --branch %s --',
	$target->getRemote().'/'.$target->getRef());
	if ($err) {
	throw new ArcanistUsageException(
	pht(
	'Perforce sync failed! Fix the error and run "arc land" again.'));
	}

	return $this->getLandTargetLocalCommit($target);
	}

	$exists = $this->getLandTargetLocalExists($target);
	if (!$exists) {
	$log->writeWarning(
	pht('TARGET'),
	pht(
	'No local copy of ref "%s" in remote "%s" exists, attempting '.
	'fetch...',
	$target->getRef(),
	$target->getRemote()));

	$this->fetchLandTarget($target, $ignore_failure = true);

	$exists = $this->getLandTargetLocalExists($target);
	if (!$exists) {
	return null;
	}

	$log->writeStatus(
	pht('FETCHED'),
	pht(
	'Fetched ref "%s" from remote "%s".',
	$target->getRef(),
	$target->getRemote()));

	return $this->getLandTargetLocalCommit($target);
	}

	$log->writeStatus(
	pht('FETCH'),
	pht(
	'Fetching "%s" from remote "%s"...',
	$target->getRef(),
	$target->getRemote()));

	$this->fetchLandTarget($target, $ignore_failure = false);

	return $this->getLandTargetLocalCommit($target);
	}

	protected function executeMerge(ArcanistLandCommitSet $set, $into_commit) {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	$this->confirmLegacyStrategyConfiguration();

	$is_empty = ($into_commit === null);

	if ($is_empty) {
	$empty_commit = ArcanistGitRawCommit::newEmptyCommit();
	$into_commit = $api->writeRawCommit($empty_commit);
	}

	$commits = $set->getCommits();

	$min_commit = head($commits);
	$min_hash = $min_commit->getHash();

	$max_commit = last($commits);
	$max_hash = $max_commit->getHash();

	// NOTE: See T11435 for some history. See PHI1727 for a case where a user
	// modified their working copy while running "arc land". This attempts to
	// resist incorrectly detecting simultaneous working copy modifications
	// as changes.

	list($changes) = $api->execxLocal(
	- 'diff --no-ext-diff %s..%s --',
	- $into_commit,
	- $max_hash);
	+ 'diff --no-ext-diff %s --',
	+ gitsprintf(
	+ '%s..%s',
	+ $into_commit,
	+ $max_hash));
	$changes = trim($changes);
	if (!strlen($changes)) {

	// TODO: We could make a more significant effort to identify the
	// human-readable symbol which led us to try to land this ref.

	throw new PhutilArgumentUsageException(
	pht(
	'Merging local "%s" into "%s" produces an empty diff. '.
	'This usually means these changes have already landed.',
	$api->getDisplayHash($max_hash),
	$api->getDisplayHash($into_commit)));
	}

	$log->writeStatus(
	pht('MERGING'),
	pht(
	'%s %s',
	$api->getDisplayHash($max_hash),
	$max_commit->getDisplaySummary()));

	$argv = array();
	$argv[] = '--no-stat';
	$argv[] = '--no-commit';

	// When we're merging into the empty state, Git refuses to perform the
	// merge until we tell it explicitly that we're doing something unusual.
	if ($is_empty) {
	$argv[] = '--allow-unrelated-histories';
	}

	if ($this->isSquashStrategy()) {
	// NOTE: We're explicitly specifying "--ff" to override the presence
	// of "merge.ff" options in user configuration.
	$argv[] = '--ff';
	$argv[] = '--squash';
	} else {
	$argv[] = '--no-ff';
	}

	$argv[] = '--';

	$is_rebasing = false;
	$is_merging = false;
	try {
	if ($this->isSquashStrategy() && !$is_empty) {
	// If we're performing a squash merge, we're going to rebase the
	// commit range first. We only want to merge the specific commits
	// in the range, and merging too much can create conflicts.

	$api->execxLocal('checkout %s --', $max_hash);

	$is_rebasing = true;
	$api->execxLocal(
	'rebase --onto %s -- %s',
	$into_commit,
	$min_hash.'^');
	$is_rebasing = false;

	$merge_hash = $api->getCanonicalRevisionName('HEAD');
	} else {
	$merge_hash = $max_hash;
	}

	$api->execxLocal('checkout %s --', $into_commit);

	$argv[] = $merge_hash;

	$is_merging = true;
	$api->execxLocal('merge %Ls', $argv);
	$is_merging = false;
	} catch (CommandException $ex) {
	$direct_symbols = $max_commit->getDirectSymbols();
	$indirect_symbols = $max_commit->getIndirectSymbols();
	if ($direct_symbols) {
	$message = pht(
	'Local commit "%s" (%s) does not merge cleanly into "%s". '.
	'Merge or rebase local changes so they can merge cleanly.',
	$api->getDisplayHash($max_hash),
	$this->getDisplaySymbols($direct_symbols),
	$api->getDisplayHash($into_commit));
	} else if ($indirect_symbols) {
	$message = pht(
	'Local commit "%s" (reachable from: %s) does not merge cleanly '.
	'into "%s". Merge or rebase local changes so they can merge '.
	'cleanly.',
	$api->getDisplayHash($max_hash),
	$this->getDisplaySymbols($indirect_symbols),
	$api->getDisplayHash($into_commit));
	} else {
	$message = pht(
	'Local commit "%s" does not merge cleanly into "%s". Merge or '.
	'rebase local changes so they can merge cleanly.',
	$api->getDisplayHash($max_hash),
	$api->getDisplayHash($into_commit));
	}

	echo tsprintf(
	"\n%!\n%W\n\n",
	pht('MERGE CONFLICT'),
	$message);

	if ($this->getHasUnpushedChanges()) {
	echo tsprintf(
	"%?\n\n",
	pht(
	'Use "--incremental" to merge and push changes one by one.'));
	}

	if ($is_rebasing) {
	$api->execManualLocal('rebase --abort');
	}

	if ($is_merging) {
	$api->execManualLocal('merge --abort');
	}

	if ($is_merging \|\| $is_rebasing) {
	$api->execManualLocal('reset --hard HEAD --');
	}

	throw new PhutilArgumentUsageException(
	pht('Encountered a merge conflict.'));
	}

	list($original_author, $original_date) = $this->getAuthorAndDate(
	$max_hash);

	$revision_ref = $set->getRevisionRef();
	$commit_message = $revision_ref->getCommitMessage();

	$future = $api->execFutureLocal(
	'commit --author %s --date %s -F - --',
	$original_author,
	$original_date);
	$future->write($commit_message);
	$future->resolvex();

	list($stdout) = $api->execxLocal('rev-parse --verify %s', 'HEAD');
	$new_cursor = trim($stdout);

	if ($is_empty) {
	// See T12876. If we're landing into the empty state, we just did a fake
	// merge on top of an empty commit. We're now on a commit with all of the
	// right details except that it has an extra empty commit as a parent.

	// Create a new commit which is the same as the current HEAD, except that
	// it doesn't have the extra parent.

	$raw_commit = $api->readRawCommit($new_cursor);
	if ($this->isSquashStrategy()) {
	$raw_commit->setParents(array());
	} else {
	$raw_commit->setParents(array($merge_hash));
	}
	$new_cursor = $api->writeRawCommit($raw_commit);

	$api->execxLocal('checkout %s --', $new_cursor);
	}

	return $new_cursor;
	}

	protected function pushChange($into_commit) {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	if ($this->getIsGitPerforce()) {

	// TODO: Specifying "--onto" more than once is almost certainly an error
	// in Perforce.

	$log->writeStatus(
	pht('SUBMITTING'),
	pht(
	'Submitting changes to "%s".',
	$this->getOntoRemote()));

	$config_argv = array();

	// Skip the "git p4 submit" interactive editor workflow. We expect
	// the commit message that "arc land" has built to be satisfactory.
	$config_argv[] = '-c';
	$config_argv[] = 'git-p4.skipSubmitEdit=true';

	// Skip the "git p4 submit" confirmation prompt if the user does not edit
	// the submit message.
	$config_argv[] = '-c';
	$config_argv[] = 'git-p4.skipSubmitEditCheck=true';

	$flags_argv = array();

	// Disable implicit "git p4 rebase" as part of submit. We're allowing
	// the implicit "git p4 sync" to go through since this puts us in a
	// state which is generally similar to the state after "git push", with
	// updated remotes.

	// We could do a manual "git p4 sync" with a more narrow "--branch"
	// instead, but it's not clear that this is beneficial.
	$flags_argv[] = '--disable-rebase';

	// Detect moves and submit them to Perforce as move operations.
	$flags_argv[] = '-M';

	// If we run into a conflict, abort the operation. We expect users to
	// fix conflicts and run "arc land" again.
	$flags_argv[] = '--conflict=quit';

	$err = $this->newPassthru(
	'%LR p4 submit %LR --commit %R --',
	$config_argv,
	$flags_argv,
	$into_commit);
	if ($err) {
	throw new ArcanistLandPushFailureException(
	pht(
	'Submit failed! Fix the error and run "arc land" again.'));
	}

	return;
	}

	$log->writeStatus(
	pht('PUSHING'),
	pht('Pushing changes to "%s".', $this->getOntoRemote()));

	$err = $this->newPassthru(
	'push -- %s %Ls',
	$this->getOntoRemote(),
	$this->newOntoRefArguments($into_commit));

	if ($err) {
	throw new ArcanistLandPushFailureException(
	pht(
	'Push failed! Fix the error and run "arc land" again.'));
	}
	}

	protected function reconcileLocalState(
	$into_commit,
	ArcanistRepositoryLocalState $state) {

	$api = $this->getRepositoryAPI();
	$log = $this->getWorkflow()->getLogEngine();

	// Try to put the user into the best final state we can. This is very
	// complicated because users are incredibly creative and their local
	// branches may, for example, have the same names as branches in the
	// remote but no relationship to them.

	// First, we're going to try to update these local branches:
	//
	// - the branch we started on originally; and
	// - the local upstreams of the branch we started on originally; and
	// - the local branch with the same name as the "into" ref; and
	// - the local branch with the same name as the "onto" ref.
	//
	// These branches may not all exist and may not all be unique.
	//
	// To be updated, these branches must:
	//
	// - exist;
	// - have not been deleted; and
	// - be connected to the remote we pushed into.

	$update_branches = array();

	$local_ref = $state->getLocalRef();
	if ($local_ref !== null) {
	$update_branches[] = $local_ref;
	}

	$local_path = $state->getLocalPath();
	if ($local_path) {
	foreach ($local_path->getLocalBranches() as $local_branch) {
	$update_branches[] = $local_branch;
	}
	}

	if (!$this->getIntoEmpty() && !$this->getIntoLocal()) {
	$update_branches[] = $this->getIntoRef();
	}

	foreach ($this->getOntoRefs() as $onto_ref) {
	$update_branches[] = $onto_ref;
	}

	$update_branches = array_fuse($update_branches);

	// Remove any branches we know we deleted.
	foreach ($update_branches as $key => $update_branch) {
	if (isset($this->deletedBranches[$update_branch])) {
	unset($update_branches[$key]);
	}
	}

	// Now, remove any branches which don't actually exist.
	foreach ($update_branches as $key => $update_branch) {
	list($err) = $api->execManualLocal(
	'rev-parse --verify %s',
	$update_branch);
	if ($err) {
	unset($update_branches[$key]);
	}
	}

	$is_perforce = $this->getIsGitPerforce();
	if ($is_perforce) {
	// If we're in Perforce mode, we don't expect to have a meaningful
	// path to the remote: the "p4" remote is not a real remote, and
	// "git p4" commands do not configure branch upstreams to provide
	// a path.

	// Additionally, we've already set the remote to the right state with an
	// implicit "git p4 sync" during "git p4 submit", and "git pull" isn't a
	// meaningful operation.

	// We're going to skip everything here and just switch to the most
	// desirable branch (if we can find one), then reset the state (if that
	// operation is safe).

	if (!$update_branches) {
	$log->writeStatus(
	pht('DETACHED HEAD'),
	pht(
	'Unable to find any local branches to update, staying on '.
	'detached head.'));
	$state->discardLocalState();
	return;
	}

	$dst_branch = head($update_branches);
	if (!$this->isAncestorOf($dst_branch, $into_commit)) {
	$log->writeStatus(
	pht('CHECKOUT'),
	pht(
	'Local branch "%s" has unpublished changes, checking it out '.
	'but leaving them in place.',
	$dst_branch));
	$do_reset = false;
	} else {
	$log->writeStatus(
	pht('UPDATE'),
	pht(
	'Switching to local branch "%s".',
	$dst_branch));
	$do_reset = true;
	}

	$api->execxLocal('checkout %s --', $dst_branch);

	if ($do_reset) {
	$api->execxLocal('reset --hard %s --', $into_commit);
	}

	$state->discardLocalState();
	return;
	}

	$onto_refs = array_fuse($this->getOntoRefs());

	$pull_branches = array();
	foreach ($update_branches as $update_branch) {
	$update_path = $api->getPathToUpstream($update_branch);

	// Remove any branches which contain upstream cycles.
	if ($update_path->getCycle()) {
	$log->writeWarning(
	pht('LOCAL CYCLE'),
	pht(
	'Local branch "%s" tracks an upstream but following it leads to '.
	'a local cycle, ignoring branch.',
	$update_branch));
	continue;
	}

	// Remove any branches not connected to a remote.
	if (!$update_path->isConnectedToRemote()) {
	continue;
	}

	// Remove any branches connected to a remote other than the remote
	// we actually pushed to.
	$remote_name = $update_path->getRemoteRemoteName();
	if ($remote_name !== $this->getOntoRemote()) {
	continue;
	}

	// Remove any branches not connected to a branch we pushed to.
	$remote_branch = $update_path->getRemoteBranchName();
	if (!isset($onto_refs[$remote_branch])) {
	continue;
	}

	// This is the most-desirable path between some local branch and
	// an impacted upstream. Select it and continue.
	$pull_branches = $update_path->getLocalBranches();
	break;
	}

	// When we update these branches later, we want to start with the branch
	// closest to the upstream and work our way down.
	$pull_branches = array_reverse($pull_branches);
	$pull_branches = array_fuse($pull_branches);

	// If we started on a branch and it still exists but is not impacted
	// by the changes we made to the remote (i.e., we aren't actually going
	// to pull or update it if we continue), just switch back to it now. It's
	// okay if this branch is completely unrelated to the changes we just
	// landed.

	if ($local_ref !== null) {
	if (isset($update_branches[$local_ref])) {
	if (!isset($pull_branches[$local_ref])) {

	$log->writeStatus(
	pht('RETURN'),
	pht(
	'Returning to original branch "%s" in original state.',
	$local_ref));

	$state->restoreLocalState();
	return;
	}
	}
	}

	// Otherwise, if we don't have any path from the upstream to any local
	// branch, we don't want to switch to some unrelated branch which happens
	// to have the same name as a branch we interacted with. Just stay where
	// we ended up.

	$dst_branch = null;
	if ($pull_branches) {
	$dst_branch = null;
	foreach ($pull_branches as $pull_branch) {
	if (!$this->isAncestorOf($pull_branch, $into_commit)) {

	$log->writeStatus(
	pht('LOCAL CHANGES'),
	pht(
	'Local branch "%s" has unpublished changes, ending updates.',
	$pull_branch));

	break;
	}

	$log->writeStatus(
	pht('UPDATE'),
	pht(
	'Updating local branch "%s"...',
	$pull_branch));

	$api->execxLocal(
	'branch -f %s %s --',
	$pull_branch,
	$into_commit);

	$dst_branch = $pull_branch;
	}
	}

	if ($dst_branch) {
	$log->writeStatus(
	pht('CHECKOUT'),
	pht(
	'Checking out "%s".',
	$dst_branch));

	$api->execxLocal('checkout %s --', $dst_branch);
	} else {
	$log->writeStatus(
	pht('DETACHED HEAD'),
	pht(
	'Unable to find any local branches to update, staying on '.
	'detached head.'));
	}

	$state->discardLocalState();
	}

	private function isAncestorOf($branch, $commit) {
	$api = $this->getRepositoryAPI();

	list($stdout) = $api->execxLocal(
	- 'merge-base %s %s',
	+ 'merge-base -- %s %s',
	$branch,
	$commit);
	$merge_base = trim($stdout);

	list($stdout) = $api->execxLocal(
	'rev-parse --verify %s',
	$branch);
	$branch_hash = trim($stdout);

	return ($merge_base === $branch_hash);
	}

	private function getAuthorAndDate($commit) {
	$api = $this->getRepositoryAPI();

	list($info) = $api->execxLocal(
	'log -n1 --format=%s %s --',
	'%aD%n%an%n%ae',
	- $commit);
	+ gitsprintf('%s', $commit));

	$info = trim($info);
	list($date, $author, $email) = explode("\n", $info, 3);

	return array(
	"$author <{$email}>",
	$date,
	);
	}

	protected function didHoldChanges($into_commit) {
	$log = $this->getLogEngine();
	$local_state = $this->getLocalState();

	if ($this->getIsGitPerforce()) {
	$message = pht(
	'Holding changes locally, they have not been submitted.');

	$push_command = csprintf(
	'git p4 submit -M --commit %s --',
	$into_commit);
	} else {
	$message = pht(
	'Holding changes locally, they have not been pushed.');

	$push_command = csprintf(
	'git push -- %s %Ls',
	$this->getOntoRemote(),
	$this->newOntoRefArguments($into_commit));
	}

	echo tsprintf(
	"\n%!\n%s\n\n",
	pht('HOLD CHANGES'),
	$message);

	echo tsprintf(
	"%s\n\n%>\n",
	pht('To push changes manually, run this command:'),
	$push_command);

	$restore_commands = $local_state->getRestoreCommandsForDisplay();
	if ($restore_commands) {
	echo tsprintf(
	"%s\n\n",
	pht(
	'To go back to how things were before you ran "arc land", run '.
	'these %s command(s):',
	phutil_count($restore_commands)));

	foreach ($restore_commands as $restore_command) {
	echo tsprintf('%>', $restore_command);
	}

	echo tsprintf("\n");
	}

	echo tsprintf(
	"%s\n",
	pht(
	'Local branches have not been changed, and are still in the '.
	'same state as before.'));
	}

	protected function resolveSymbols(array $symbols) {
	assert_instances_of($symbols, 'ArcanistLandSymbol');
	$api = $this->getRepositoryAPI();

	foreach ($symbols as $symbol) {
	$raw_symbol = $symbol->getSymbol();

	list($err, $stdout) = $api->execManualLocal(
	'rev-parse --verify %s',
	$raw_symbol);

	if ($err) {
	throw new PhutilArgumentUsageException(
	pht(
	'Branch "%s" does not exist in the local working copy.',
	$raw_symbol));
	}

	$commit = trim($stdout);
	$symbol->setCommit($commit);
	}
	}

	protected function confirmOntoRefs(array $onto_refs) {
	$api = $this->getRepositoryAPI();

	foreach ($onto_refs as $onto_ref) {
	if (!strlen($onto_ref)) {
	throw new PhutilArgumentUsageException(
	pht(
	'Selected "onto" ref "%s" is invalid: the empty string is not '.
	'a valid ref.',
	$onto_ref));
	}
	}

	$markers = $api->newMarkerRefQuery()
	->withRemotes(array($this->getOntoRemoteRef()))
	->withNames($onto_refs)
	->execute();

	$markers = mgroup($markers, 'getName');

	$new_markers = array();
	foreach ($onto_refs as $onto_ref) {
	if (isset($markers[$onto_ref])) {
	// Remote already has a branch with this name, so we're fine: we
	// aren't creatinga new branch.
	continue;
	}

	$new_markers[] = id(new ArcanistMarkerRef())
	->setMarkerType(ArcanistMarkerRef::TYPE_BRANCH)
	->setName($onto_ref);
	}

	if ($new_markers) {
	echo tsprintf(
	"\n%!\n%W\n\n",
	pht('CREATE %s BRANCHE(S)', phutil_count($new_markers)),
	pht(
	'These %s symbol(s) do not exist in the remote. They will be '.
	'created as new branches:',
	phutil_count($new_markers)));

	foreach ($new_markers as $new_marker) {
	echo tsprintf('%s', $new_marker->newRefView());
	}

	echo tsprintf("\n");

	$is_hold = $this->getShouldHold();
	if ($is_hold) {
	echo tsprintf(
	"%?\n",
	pht(
	'You are using "--hold", so execution will stop before the '.
	'%s branche(s) are actually created. You will be given '.
	'instructions to create the branches.',
	phutil_count($new_markers)));
	}

	$query = pht(
	'Create %s new branche(s) in the remote?',
	phutil_count($new_markers));

	$this->getWorkflow()
	->getPrompt('arc.land.create')
	->setQuery($query)
	->execute();
	}
	}

	protected function selectOntoRefs(array $symbols) {
	assert_instances_of($symbols, 'ArcanistLandSymbol');
	$log = $this->getLogEngine();

	$onto = $this->getOntoArguments();
	if ($onto) {

	$log->writeStatus(
	pht('ONTO TARGET'),
	pht(
	'Refs were selected with the "--onto" flag: %s.',
	implode(', ', $onto)));

	return $onto;
	}

	$onto = $this->getOntoFromConfiguration();
	if ($onto) {
	$onto_key = $this->getOntoConfigurationKey();

	$log->writeStatus(
	pht('ONTO TARGET'),
	pht(
	'Refs were selected by reading "%s" configuration: %s.',
	$onto_key,
	implode(', ', $onto)));

	return $onto;
	}

	$api = $this->getRepositoryAPI();

	$remote_onto = array();
	foreach ($symbols as $symbol) {
	$raw_symbol = $symbol->getSymbol();
	$path = $api->getPathToUpstream($raw_symbol);

	if (!$path->getLength()) {
	continue;
	}

	$cycle = $path->getCycle();
	if ($cycle) {
	$log->writeWarning(
	pht('LOCAL CYCLE'),
	pht(
	'Local branch "%s" tracks an upstream, but following it leads '.
	'to a local cycle; ignoring branch upstream.',
	$raw_symbol));

	$log->writeWarning(
	pht('LOCAL CYCLE'),
	implode(' -> ', $cycle));

	continue;
	}

	if (!$path->isConnectedToRemote()) {
	$log->writeWarning(
	pht('NO PATH TO REMOTE'),
	pht(
	'Local branch "%s" tracks an upstream, but there is no path '.
	'to a remote; ignoring branch upstream.',
	$raw_symbol));

	continue;
	}

	$onto = $path->getRemoteBranchName();

	$remote_onto[$onto] = $onto;
	}

	if (count($remote_onto) > 1) {
	throw new PhutilArgumentUsageException(
	pht(
	'The branches you are landing are connected to multiple different '.
	'remote branches via Git branch upstreams. Use "--onto" to select '.
	'the refs you want to push to.'));
	}

	if ($remote_onto) {
	$remote_onto = array_values($remote_onto);

	$log->writeStatus(
	pht('ONTO TARGET'),
	pht(
	'Landing onto target "%s", selected by following tracking branches '.
	'upstream to the closest remote branch.',
	head($remote_onto)));

	return $remote_onto;
	}

	$default_onto = 'master';

	$log->writeStatus(
	pht('ONTO TARGET'),
	pht(
	'Landing onto target "%s", the default target under Git.',
	$default_onto));

	return array($default_onto);
	}

	protected function selectOntoRemote(array $symbols) {
	assert_instances_of($symbols, 'ArcanistLandSymbol');
	$remote = $this->newOntoRemote($symbols);

	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();
	$is_pushable = $api->isPushableRemote($remote);
	$is_perforce = $api->isPerforceRemote($remote);

	if (!$is_pushable && !$is_perforce) {
	throw new PhutilArgumentUsageException(
	pht(
	'No pushable remote "%s" exists. Use the "--onto-remote" flag to '.
	'choose a valid, pushable remote to land changes onto.',
	$remote));
	}

	if ($is_perforce) {
	$this->setIsGitPerforce(true);

	$log->writeWarning(
	pht('P4 MODE'),
	pht(
	'Operating in Git/Perforce mode after selecting a Perforce '.
	'remote.'));

	if (!$this->isSquashStrategy()) {
	throw new PhutilArgumentUsageException(
	pht(
	'Perforce mode does not support the "merge" land strategy. '.
	'Use the "squash" land strategy when landing to a Perforce '.
	'remote (you can use "--squash" to select this strategy).'));
	}
	}

	return $remote;
	}

	private function newOntoRemote(array $onto_symbols) {
	assert_instances_of($onto_symbols, 'ArcanistLandSymbol');
	$log = $this->getLogEngine();

	$remote = $this->getOntoRemoteArgument();
	if ($remote !== null) {

	$log->writeStatus(
	pht('ONTO REMOTE'),
	pht(
	'Remote "%s" was selected with the "--onto-remote" flag.',
	$remote));

	return $remote;
	}

	$remote = $this->getOntoRemoteFromConfiguration();
	if ($remote !== null) {
	$remote_key = $this->getOntoRemoteConfigurationKey();

	$log->writeStatus(
	pht('ONTO REMOTE'),
	pht(
	'Remote "%s" was selected by reading "%s" configuration.',
	$remote,
	$remote_key));

	return $remote;
	}

	$api = $this->getRepositoryAPI();

	$upstream_remotes = array();
	foreach ($onto_symbols as $onto_symbol) {
	$path = $api->getPathToUpstream($onto_symbol->getSymbol());

	$remote = $path->getRemoteRemoteName();
	if ($remote !== null) {
	$upstream_remotes[$remote][] = $onto_symbol;
	}
	}

	if (count($upstream_remotes) > 1) {
	throw new PhutilArgumentUsageException(
	pht(
	'The "onto" refs you have selected are connected to multiple '.
	'different remotes via Git branch upstreams. Use "--onto-remote" '.
	'to select a single remote.'));
	}

	if ($upstream_remotes) {
	$upstream_remote = head_key($upstream_remotes);

	$log->writeStatus(
	pht('ONTO REMOTE'),
	pht(
	'Remote "%s" was selected by following tracking branches '.
	'upstream to the closest remote.',
	$remote));

	return $upstream_remote;
	}

	$perforce_remote = 'p4';
	if ($api->isPerforceRemote($remote)) {

	$log->writeStatus(
	pht('ONTO REMOTE'),
	pht(
	'Peforce remote "%s" was selected because the existence of '.
	'this remote implies this working copy was synchronized '.
	'from a Perforce repository.',
	$remote));

	return $remote;
	}

	$default_remote = 'origin';

	$log->writeStatus(
	pht('ONTO REMOTE'),
	pht(
	'Landing onto remote "%s", the default remote under Git.',
	$default_remote));

	return $default_remote;
	}

	protected function selectIntoRemote() {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	if ($this->getIntoEmptyArgument()) {
	$this->setIntoEmpty(true);

	$log->writeStatus(
	pht('INTO REMOTE'),
	pht(
	'Will merge into empty state, selected with the "--into-empty" '.
	'flag.'));

	return;
	}

	if ($this->getIntoLocalArgument()) {
	$this->setIntoLocal(true);

	$log->writeStatus(
	pht('INTO REMOTE'),
	pht(
	'Will merge into local state, selected with the "--into-local" '.
	'flag.'));

	return;
	}

	$into = $this->getIntoRemoteArgument();
	if ($into !== null) {

	// TODO: We could allow users to pass a URI argument instead, but
	// this also requires some updates to the fetch logic elsewhere.

	if (!$api->isFetchableRemote($into)) {
	throw new PhutilArgumentUsageException(
	pht(
	'Remote "%s", specified with "--into", is not a valid fetchable '.
	'remote.',
	$into));
	}

	$this->setIntoRemote($into);

	$log->writeStatus(
	pht('INTO REMOTE'),
	pht(
	'Will merge into remote "%s", selected with the "--into" flag.',
	$into));

	return;
	}

	$onto = $this->getOntoRemote();
	$this->setIntoRemote($onto);

	$log->writeStatus(
	pht('INTO REMOTE'),
	pht(
	'Will merge into remote "%s" by default, because this is the remote '.
	'the change is landing onto.',
	$onto));
	}

	protected function selectIntoRef() {
	$log = $this->getLogEngine();

	if ($this->getIntoEmptyArgument()) {
	$log->writeStatus(
	pht('INTO TARGET'),
	pht(
	'Will merge into empty state, selected with the "--into-empty" '.
	'flag.'));

	return;
	}

	$into = $this->getIntoArgument();
	if ($into !== null) {
	$this->setIntoRef($into);

	$log->writeStatus(
	pht('INTO TARGET'),
	pht(
	'Will merge into target "%s", selected with the "--into" flag.',
	$into));

	return;
	}

	$ontos = $this->getOntoRefs();
	$onto = head($ontos);

	$this->setIntoRef($onto);
	if (count($ontos) > 1) {
	$log->writeStatus(
	pht('INTO TARGET'),
	pht(
	'Will merge into target "%s" by default, because this is the first '.
	'"onto" target.',
	$onto));
	} else {
	$log->writeStatus(
	pht('INTO TARGET'),
	pht(
	'Will merge into target "%s" by default, because this is the "onto" '.
	'target.',
	$onto));
	}
	}

	protected function selectIntoCommit() {
	$api = $this->getRepositoryAPI();
	// Make sure that our "into" target is valid.
	$log = $this->getLogEngine();
	$api = $this->getRepositoryAPI();

	if ($this->getIntoEmpty()) {
	// If we're running under "--into-empty", we don't have to do anything.

	$log->writeStatus(
	pht('INTO COMMIT'),
	pht('Preparing merge into the empty state.'));

	return null;
	}

	if ($this->getIntoLocal()) {
	// If we're running under "--into-local", just make sure that the
	// target identifies some actual commit.
	$local_ref = $this->getIntoRef();

	list($err, $stdout) = $api->execManualLocal(
	'rev-parse --verify %s',
	$local_ref);

	if ($err) {
	throw new PhutilArgumentUsageException(
	pht(
	'Local ref "%s" does not exist.',
	$local_ref));
	}

	$into_commit = trim($stdout);

	$log->writeStatus(
	pht('INTO COMMIT'),
	pht(
	'Preparing merge into local target "%s", at commit "%s".',
	$local_ref,
	$api->getDisplayHash($into_commit)));

	return $into_commit;
	}

	$target = id(new ArcanistLandTarget())
	->setRemote($this->getIntoRemote())
	->setRef($this->getIntoRef());

	$commit = $this->fetchTarget($target);
	if ($commit !== null) {
	$log->writeStatus(
	pht('INTO COMMIT'),
	pht(
	'Preparing merge into "%s" from remote "%s", at commit "%s".',
	$target->getRef(),
	$target->getRemote(),
	$api->getDisplayHash($commit)));
	return $commit;
	}

	// If we have no valid target and the user passed "--into" explicitly,
	// treat this as an error. For example, "arc land --into Q --onto Q",
	// where "Q" does not exist, is an error.
	if ($this->getIntoArgument()) {
	throw new PhutilArgumentUsageException(
	pht(
	'Ref "%s" does not exist in remote "%s".',
	$target->getRef(),
	$target->getRemote()));
	}

	// Otherwise, treat this as implying "--into-empty". For example,
	// "arc land --onto Q", where "Q" does not exist, is equivalent to
	// "arc land --into-empty --onto Q".
	$this->setIntoEmpty(true);

	$log->writeStatus(
	pht('INTO COMMIT'),
	pht(
	'Preparing merge into the empty state to create target "%s" '.
	'in remote "%s".',
	$target->getRef(),
	$target->getRemote()));

	return null;
	}

	private function getLandTargetLocalCommit(ArcanistLandTarget $target) {
	$commit = $this->resolveLandTargetLocalCommit($target);

	if ($commit === null) {
	throw new Exception(
	pht(
	'No ref "%s" exists in remote "%s".',
	$target->getRef(),
	$target->getRemote()));
	}

	return $commit;
	}

	private function getLandTargetLocalExists(ArcanistLandTarget $target) {
	$commit = $this->resolveLandTargetLocalCommit($target);
	return ($commit !== null);
	}

	private function resolveLandTargetLocalCommit(ArcanistLandTarget $target) {
	$target_key = $target->getLandTargetKey();

	if (!array_key_exists($target_key, $this->landTargetCommitMap)) {
	$full_ref = sprintf(
	'refs/remotes/%s/%s',
	$target->getRemote(),
	$target->getRef());

	$api = $this->getRepositoryAPI();

	list($err, $stdout) = $api->execManualLocal(
	'rev-parse --verify %s',
	$full_ref);

	if ($err) {
	$result = null;
	} else {
	$result = trim($stdout);
	}

	$this->landTargetCommitMap[$target_key] = $result;
	}

	return $this->landTargetCommitMap[$target_key];
	}

	private function fetchLandTarget(
	ArcanistLandTarget $target,
	$ignore_failure = false) {
	$api = $this->getRepositoryAPI();

	$err = $this->newPassthru(
	'fetch --no-tags --quiet -- %s %s',
	$target->getRemote(),
	$target->getRef());
	if ($err && !$ignore_failure) {
	throw new ArcanistUsageException(
	pht(
	'Fetch of "%s" from remote "%s" failed! Fix the error and '.
	'run "arc land" again.',
	$target->getRef(),
	$target->getRemote()));
	}

	// TODO: If the remote is a bare URI, we could read ".git/FETCH_HEAD"
	// here and write the commit into the map. For now, settle for clearing
	// the cache.

	// We could also fetch into some named "refs/arc-land-temporary" named
	// ref, then read that.

	if (!$err) {
	$target_key = $target->getLandTargetKey();
	unset($this->landTargetCommitMap[$target_key]);
	}
	}

	protected function selectCommits($into_commit, array $symbols) {
	assert_instances_of($symbols, 'ArcanistLandSymbol');
	$api = $this->getRepositoryAPI();

	$commit_map = array();
	foreach ($symbols as $symbol) {
	$symbol_commit = $symbol->getCommit();
	- $format = '%H%x00%P%x00%s%x00';
	+ $format = '--format=%H%x00%P%x00%s%x00';

	if ($into_commit === null) {
	list($commits) = $api->execxLocal(
	- 'log %s --format=%s',
	- $symbol_commit,
	- $format);
	+ 'log %s %s --',
	+ $format,
	+ gitsprintf('%s', $symbol_commit));
	} else {
	list($commits) = $api->execxLocal(
	- 'log %s --not %s --format=%s',
	- $symbol_commit,
	- $into_commit,
	- $format);
	+ 'log %s %s --not %s --',
	+ $format,
	+ gitsprintf('%s', $symbol_commit),
	+ gitsprintf('%s', $into_commit));
	}

	$commits = phutil_split_lines($commits, false);
	$is_first = true;
	foreach ($commits as $line) {
	if (!strlen($line)) {
	continue;
	}

	$parts = explode("\0", $line, 4);
	if (count($parts) < 3) {
	throw new Exception(
	pht(
	'Unexpected output from "git log ...": %s',
	$line));
	}

	$hash = $parts[0];
	if (!isset($commit_map[$hash])) {
	$parents = $parts[1];
	$parents = trim($parents);
	if (strlen($parents)) {
	$parents = explode(' ', $parents);
	} else {
	$parents = array();
	}

	$summary = $parts[2];

	$commit_map[$hash] = id(new ArcanistLandCommit())
	->setHash($hash)
	->setParents($parents)
	->setSummary($summary);
	}

	$commit = $commit_map[$hash];
	if ($is_first) {
	$commit->addDirectSymbol($symbol);
	$is_first = false;
	}

	$commit->addIndirectSymbol($symbol);
	}
	}

	return $this->confirmCommits($into_commit, $symbols, $commit_map);
	}

	protected function getDefaultSymbols() {
	$api = $this->getRepositoryAPI();
	$log = $this->getLogEngine();

	$branch = $api->getBranchName();
	if ($branch !== null) {
	$log->writeStatus(
	pht('SOURCE'),
	pht(
	'Landing the current branch, "%s".',
	$branch));

	return array($branch);
	}

	$commit = $api->getCurrentCommitRef();

	$log->writeStatus(
	pht('SOURCE'),
	pht(
	'Landing the current HEAD, "%s".',
	$commit->getCommitHash()));

	return array($commit->getCommitHash());
	}

	private function newOntoRefArguments($into_commit) {
	$api = $this->getRepositoryAPI();
	$refspecs = array();

	foreach ($this->getOntoRefs() as $onto_ref) {
	$refspecs[] = sprintf(
	'%s:refs/heads/%s',
	$api->getDisplayHash($into_commit),
	$onto_ref);
	}

	return $refspecs;
	}

	private function confirmLegacyStrategyConfiguration() {
	// TODO: See T13547. Remove this check in the future. This prevents users
	// from accidentally executing a "squash" workflow under a configuration
	// which would previously have executed a "merge" workflow.

	// We're fine if we have an explicit "--strategy".
	if ($this->getStrategyArgument() !== null) {
	return;
	}

	// We're fine if we have an explicit "arc.land.strategy".
	if ($this->getStrategyFromConfiguration() !== null) {
	return;
	}

	// We're fine if "history.immutable" is not set to "true".
	$source_list = $this->getWorkflow()->getConfigurationSourceList();
	$config_list = $source_list->getStorageValueList('history.immutable');
	if (!$config_list) {
	return;
	}

	$config_value = (bool)last($config_list)->getValue();
	if (!$config_value) {
	return;
	}

	// We're in trouble: we would previously have selected "merge" and will
	// now select "squash". Make sure the user knows what they're in for.

	echo tsprintf(
	"\n%!\n%W\n\n",
	pht('MERGE STRATEGY IS AMBIGUOUS'),
	pht(
	'See <%s>. The default merge strategy under Git with '.
	'"history.immutable" has changed from "merge" to "squash". Your '.
	'configuration is ambiguous under this behavioral change. '.
	'(Use "--strategy" or configure "arc.land.strategy" to bypass '.
	'this check.)',
	'https://secure.phabricator.com/T13547'));

	throw new PhutilArgumentUsageException(
	pht(
	'Desired merge strategy is ambiguous, choose an explicit strategy.'));
	}

	}
	diff --git a/src/query/ArcanistGitCommitMessageHardpointQuery.php b/src/query/ArcanistGitCommitMessageHardpointQuery.php
	index fd5b1659..ba2a1b73 100644
	--- a/src/query/ArcanistGitCommitMessageHardpointQuery.php
	+++ b/src/query/ArcanistGitCommitMessageHardpointQuery.php
	@@ -1,48 +1,48 @@
	<?php

	final class ArcanistGitCommitMessageHardpointQuery
	extends ArcanistWorkflowGitHardpointQuery {

	public function getHardpoints() {
	return array(
	ArcanistCommitRef::HARDPOINT_MESSAGE,
	);
	}

	protected function canLoadRef(ArcanistRef $ref) {
	return ($ref instanceof ArcanistCommitRef);
	}

	public function loadHardpoint(array $refs, $hardpoint) {
	$api = $this->getRepositoryAPI();

	$hashes = mpull($refs, 'getCommitHash');
	$unique_hashes = array_fuse($hashes);

	// TODO: Update this to use "%B", see T5028. We can also bulk-resolve
	// these with "git show --quiet --format=... hash hash hash ... --".

	$futures = array();
	foreach ($unique_hashes as $hash) {
	$futures[$hash] = $api->execFutureLocal(
	'log -n1 --format=%s %s --',
	'%s%n%n%b',
	- $hash);
	+ gitsprintf('%s', $hash));
	}

	yield $this->yieldFutures($futures);

	$messages = array();
	foreach ($futures as $hash => $future) {
	list($stdout) = $future->resolvex();
	$messages[$hash] = $stdout;
	}

	foreach ($hashes as $ref_key => $hash) {
	$hashes[$ref_key] = $messages[$hash];
	}

	yield $this->yieldMap($hashes);
	}

	}
	diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
	index 2ce9e41b..6c6d2ac4 100644
	--- a/src/repository/api/ArcanistGitAPI.php
	+++ b/src/repository/api/ArcanistGitAPI.php
	@@ -1,1823 +1,1825 @@
	<?php

	/**
	* Interfaces with Git working copies.
	*/
	final class ArcanistGitAPI extends ArcanistRepositoryAPI {

	private $repositoryHasNoCommits = false;
	const SEARCH_LENGTH_FOR_PARENT_REVISIONS = 16;

	/**
	* For the repository's initial commit, 'git diff HEAD^' and similar do
	* not work. Using this instead does work; it is the hash of the empty tree.
	*/
	const GIT_MAGIC_ROOT_COMMIT = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';

	private $symbolicHeadCommit;
	private $resolvedHeadCommit;

	protected function buildLocalFuture(array $argv) {
	$argv[0] = 'git '.$argv[0];

	return newv('ExecFuture', $argv)
	->setCWD($this->getPath());
	}

	public function newPassthru($pattern /* , ... */) {
	$args = func_get_args();

	static $git = null;
	if ($git === null) {
	if (phutil_is_windows()) {
	// NOTE: On Windows, phutil_passthru() uses 'bypass_shell' because
	// everything goes to hell if we don't. We must provide an absolute
	// path to Git for this to work properly.
	$git = Filesystem::resolveBinary('git');
	$git = csprintf('%s', $git);
	} else {
	$git = 'git';
	}
	}

	$args[0] = $git.' '.$args[0];

	return newv('PhutilExecPassthru', $args)
	->setCWD($this->getPath());
	}

	public function getSourceControlSystemName() {
	return 'git';
	}

	public function getGitVersion() {
	static $version = null;
	if ($version === null) {
	list($stdout) = $this->execxLocal('--version');
	$version = rtrim(str_replace('git version ', '', $stdout));
	}
	return $version;
	}

	public function getMetadataPath() {
	static $path = null;
	if ($path === null) {
	list($stdout) = $this->execxLocal('rev-parse --git-dir');
	$path = rtrim($stdout, "\n");
	// the output of git rev-parse --git-dir is an absolute path, unless
	// the cwd is the root of the repository, in which case it uses the
	// relative path of .git. If we get this relative path, turn it into
	// an absolute path.
	if ($path === '.git') {
	$path = $this->getPath('.git');
	}
	}
	return $path;
	}

	public function getHasCommits() {
	return !$this->repositoryHasNoCommits;
	}

	/**
	* Tests if a child commit is descendant of a parent commit.
	* If child and parent are the same, it returns false.
	* @param Child commit SHA.
	* @param Parent commit SHA.
	* @return bool True if the child is a descendant of the parent.
	*/
	private function isDescendant($child, $parent) {
	list($common_ancestor) = $this->execxLocal(
	- 'merge-base %s %s',
	+ 'merge-base -- %s %s',
	$child,
	$parent);
	$common_ancestor = trim($common_ancestor);

	return ($common_ancestor == $parent) && ($common_ancestor != $child);
	}

	public function getLocalCommitInformation() {
	if ($this->repositoryHasNoCommits) {
	// Zero commits.
	throw new Exception(
	pht(
	"You can't get local commit information for a repository with no ".
	"commits."));
	} else if ($this->getBaseCommit() == self::GIT_MAGIC_ROOT_COMMIT) {
	// One commit.
	$against = 'HEAD';
	} else {

	// 2..N commits. We include commits reachable from HEAD which are
	// not reachable from the base commit; this is consistent with user
	// expectations even though it is not actually the diff range.
	// Particularly:
	//
	// \|
	// D <----- master branch
	// \|
	// C Y <- feature branch
	// \| /\|
	// B X
	// \| /
	// A
	// \|
	//
	// If "A, B, C, D" are master, and the user is at Y, when they run
	// "arc diff B" they want (and get) a diff of B vs Y, but they think about
	// this as being the commits X and Y. If we log "B..Y", we only show
	// Y. With "Y --not B", we show X and Y.


	if ($this->symbolicHeadCommit !== null) {
	$base_commit = $this->getBaseCommit();
	$resolved_base = $this->resolveCommit($base_commit);

	$head_commit = $this->symbolicHeadCommit;
	$resolved_head = $this->getHeadCommit();

	if (!$this->isDescendant($resolved_head, $resolved_base)) {
	// NOTE: Since the base commit will have been resolved as the
	// merge-base of the specified base and the specified HEAD, we can't
	// easily tell exactly what's wrong with the range.

	// For example, `arc diff HEAD --head HEAD^^^` is invalid because it
	// is reversed, but resolving the commit "HEAD" will compute its
	// merge-base with "HEAD^^^", which is "HEAD^^^", so the range will
	// appear empty.

	throw new ArcanistUsageException(
	pht(
	'The specified commit range is empty, backward or invalid: the '.
	'base (%s) is not an ancestor of the head (%s). You can not '.
	'diff an empty or reversed commit range.',
	$base_commit,
	$head_commit));
	}
	}

	$against = csprintf(
	'%s --not %s',
	$this->getHeadCommit(),
	$this->getBaseCommit());
	}

	// NOTE: Windows escaping of "%" symbols apparently is inherently broken;
	// when passed through escapeshellarg() they are replaced with spaces.

	// TODO: Learn how cmd.exe works and find some clever workaround?

	// NOTE: If we use "%x00", output is truncated in Windows.

	list($info) = $this->execxLocal(
	phutil_is_windows()
	? 'log %C --format=%C --'
	: 'log %C --format=%s --',
	$against,
	// NOTE: "%B" is somewhat new, use "%s%n%n%b" instead.
	'%H%x01%T%x01%P%x01%at%x01%an%x01%aE%x01%s%x01%s%n%n%b%x02');

	$commits = array();

	$info = trim($info, " \n\2");
	if (!strlen($info)) {
	return array();
	}

	$info = explode("\2", $info);
	foreach ($info as $line) {
	list($commit, $tree, $parents, $time, $author, $author_email,
	$title, $message) = explode("\1", trim($line), 8);
	$message = rtrim($message);

	$commits[$commit] = array(
	'commit' => $commit,
	'tree' => $tree,
	'parents' => array_filter(explode(' ', $parents)),
	'time' => $time,
	'author' => $author,
	'summary' => $title,
	'message' => $message,
	'authorEmail' => $author_email,
	);
	}

	return $commits;
	}

	protected function buildBaseCommit($symbolic_commit) {
	if ($symbolic_commit !== null) {
	if ($symbolic_commit == self::GIT_MAGIC_ROOT_COMMIT) {
	$this->setBaseCommitExplanation(
	pht('you explicitly specified the empty tree.'));
	return $symbolic_commit;
	}

	list($err, $merge_base) = $this->execManualLocal(
	- 'merge-base %s %s',
	+ 'merge-base -- %s %s',
	$symbolic_commit,
	$this->getHeadCommit());
	if ($err) {
	throw new ArcanistUsageException(
	pht(
	"Unable to find any git commit named '%s' in this repository.",
	$symbolic_commit));
	}

	if ($this->symbolicHeadCommit === null) {
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of the explicitly specified base commit ".
	"'%s' and HEAD.",
	$symbolic_commit));
	} else {
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of the explicitly specified base commit ".
	"'%s' and the explicitly specified head commit '%s'.",
	$symbolic_commit,
	$this->symbolicHeadCommit));
	}

	return trim($merge_base);
	}

	// Detect zero-commit or one-commit repositories. There is only one
	// relative-commit value that makes any sense in these repositories: the
	// empty tree.
	list($err) = $this->execManualLocal('rev-parse --verify HEAD^');
	if ($err) {
	list($err) = $this->execManualLocal('rev-parse --verify HEAD');
	if ($err) {
	$this->repositoryHasNoCommits = true;
	}

	if ($this->repositoryHasNoCommits) {
	$this->setBaseCommitExplanation(pht('the repository has no commits.'));
	} else {
	$this->setBaseCommitExplanation(
	pht('the repository has only one commit.'));
	}

	return self::GIT_MAGIC_ROOT_COMMIT;
	}

	if ($this->getBaseCommitArgumentRules() \|\|
	$this->getConfigurationManager()->getConfigFromAnySource('base')) {
	$base = $this->resolveBaseCommit();
	if (!$base) {
	throw new ArcanistUsageException(
	pht(
	"None of the rules in your 'base' configuration matched a valid ".
	"commit. Adjust rules or specify which commit you want to use ".
	"explicitly."));
	}
	return $base;
	}

	$do_write = false;
	$default_relative = null;
	$working_copy = $this->getWorkingCopyIdentity();
	if ($working_copy) {
	$default_relative = $working_copy->getProjectConfig(
	'git.default-relative-commit');
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of '%s' and HEAD, as specified in '%s' in ".
	"'%s'. This setting overrides other settings.",
	$default_relative,
	'git.default-relative-commit',
	'.arcconfig'));
	}

	if (!$default_relative) {
	list($err, $upstream) = $this->execManualLocal(
	'rev-parse --abbrev-ref --symbolic-full-name %s',
	'@{upstream}');

	if (!$err) {
	$default_relative = trim($upstream);
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of '%s' (the Git upstream ".
	"of the current branch) HEAD.",
	$default_relative));
	}
	}

	if (!$default_relative) {
	$default_relative = $this->readScratchFile('default-relative-commit');
	$default_relative = trim($default_relative);
	if ($default_relative) {
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of '%s' and HEAD, as specified in '%s'.",
	$default_relative,
	'.git/arc/default-relative-commit'));
	}
	}

	if (!$default_relative) {

	// TODO: Remove the history lesson soon.

	echo phutil_console_format(
	"<bg:green> %s </bg>\n\n",
	pht('Select a Default Commit Range'));
	echo phutil_console_wrap(
	pht(
	"You're running a command which operates on a range of revisions ".
	"(usually, from some revision to HEAD) but have not specified the ".
	"revision that should determine the start of the range.\n\n".
	"Previously, arc assumed you meant '%s' when you did not specify ".
	"a start revision, but this behavior does not make much sense in ".
	"most workflows outside of Facebook's historic %s workflow.\n\n".
	"arc no longer assumes '%s'. You must specify a relative commit ".
	"explicitly when you invoke a command (e.g., `%s`, not just `%s`) ".
	"or select a default for this working copy.\n\nIn most cases, the ".
	"best default is '%s'. You can also select '%s' to preserve the ".
	"old behavior, or some other remote or branch. But you almost ".
	"certainly want to select 'origin/master'.\n\n".
	"(Technically: the merge-base of the selected revision and HEAD is ".
	"used to determine the start of the commit range.)",
	'HEAD^',
	'git-svn',
	'HEAD^',
	'arc diff HEAD^',
	'arc diff',
	'origin/master',
	'HEAD^'));

	$prompt = pht('What default do you want to use? [origin/master]');
	$default = phutil_console_prompt($prompt);

	if (!strlen(trim($default))) {
	$default = 'origin/master';
	}

	$default_relative = $default;
	$do_write = true;
	}

	list($object_type) = $this->execxLocal(
	'cat-file -t %s',
	$default_relative);

	if (trim($object_type) !== 'commit') {
	throw new Exception(
	pht(
	"Relative commit '%s' is not the name of a commit!",
	$default_relative));
	}

	if ($do_write) {
	// Don't perform this write until we've verified that the object is a
	// valid commit name.
	$this->writeScratchFile('default-relative-commit', $default_relative);
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of '%s' and HEAD, as you just specified.",
	$default_relative));
	}

	list($merge_base) = $this->execxLocal(
	- 'merge-base %s HEAD',
	+ 'merge-base -- %s HEAD',
	$default_relative);

	return trim($merge_base);
	}

	public function getHeadCommit() {
	if ($this->resolvedHeadCommit === null) {
	$this->resolvedHeadCommit = $this->resolveCommit(
	coalesce($this->symbolicHeadCommit, 'HEAD'));
	}

	return $this->resolvedHeadCommit;
	}

	public function setHeadCommit($symbolic_commit) {
	$this->symbolicHeadCommit = $symbolic_commit;
	$this->reloadCommitRange();
	return $this;
	}

	/**
	* Translates a symbolic commit (like "HEAD^") to a commit identifier.
	* @param string_symbol commit.
	* @return string the commit SHA.
	*/
	private function resolveCommit($symbolic_commit) {
	list($err, $commit_hash) = $this->execManualLocal(
	'rev-parse %s',
	$symbolic_commit);

	if ($err) {
	throw new ArcanistUsageException(
	pht(
	"Unable to find any git commit named '%s' in this repository.",
	$symbolic_commit));
	}

	return trim($commit_hash);
	}

	private function getDiffFullOptions($detect_moves_and_renames = true) {
	$options = array(
	self::getDiffBaseOptions(),
	'--no-color',
	'--src-prefix=a/',
	'--dst-prefix=b/',
	'-U'.$this->getDiffLinesOfContext(),
	);

	if ($detect_moves_and_renames) {
	$options[] = '-M';
	$options[] = '-C';
	}

	return implode(' ', $options);
	}

	private function getDiffBaseOptions() {
	$options = array(
	// Disable external diff drivers, like graphical differs, since Arcanist
	// needs to capture the diff text.
	'--no-ext-diff',
	// Disable textconv so we treat binary files as binary, even if they have
	// an alternative textual representation. TODO: Ideally, Differential
	// would ship up the binaries for 'arc patch' but display the textconv
	// output in the visual diff.
	'--no-textconv',
	// Provide a standard view of submodule changes; the 'log' and 'diff'
	// values do not parse by the diff parser.
	'--submodule=short',
	);
	return implode(' ', $options);
	}

	/**
	* @param the base revision
	* @param head revision. If this is null, the generated diff will include the
	* working copy
	*/
	public function getFullGitDiff($base, $head = null) {
	$options = $this->getDiffFullOptions();
	$config_options = array();

	// See T13432. Disable the rare "diff.suppressBlankEmpty" configuration
	// option, which discards the " " (space) change type prefix on unchanged
	// blank lines. At time of writing the parser does not handle these
	// properly, but generating a more-standard diff is generally desirable
	// even if a future parser handles this case more gracefully.

	$config_options[] = '-c';
	$config_options[] = 'diff.suppressBlankEmpty=false';

	if ($head !== null) {
	list($stdout) = $this->execxLocal(
	"%LR diff {$options} %s %s --",
	$config_options,
	$base,
	$head);
	} else {
	list($stdout) = $this->execxLocal(
	"%LR diff {$options} %s --",
	$config_options,
	$base);
	}

	return $stdout;
	}

	/**
	* @param string Path to generate a diff for.
	* @param bool If true, detect moves and renames. Otherwise, ignore
	* moves/renames; this is useful because it prompts git to
	* generate real diff text.
	*/
	public function getRawDiffText($path, $detect_moves_and_renames = true) {
	$options = $this->getDiffFullOptions($detect_moves_and_renames);
	list($stdout) = $this->execxLocal(
	"diff {$options} %s -- %s",
	$this->getBaseCommit(),
	$path);
	return $stdout;
	}

	private function getBranchNameFromRef($ref) {
	$count = 0;
	$branch = preg_replace('/^refs\/heads\//', '', $ref, 1, $count);
	if ($count !== 1) {
	return null;
	}

	if (!strlen($branch)) {
	return null;
	}

	return $branch;
	}

	public function getBranchName() {
	list($err, $stdout, $stderr) = $this->execManualLocal(
	'symbolic-ref --quiet HEAD');

	if ($err === 0) {
	// We expect the branch name to come qualified with a refs/heads/ prefix.
	// Verify this, and strip it.
	$ref = rtrim($stdout);
	$branch = $this->getBranchNameFromRef($ref);
	if ($branch === null) {
	throw new Exception(
	pht('Failed to parse %s output!', 'git symbolic-ref'));
	}
	return $branch;
	} else if ($err === 1) {
	// Exit status 1 with --quiet indicates that HEAD is detached.
	return null;
	} else {
	throw new Exception(
	pht('Command %s failed: %s', 'git symbolic-ref', $stderr));
	}
	}

	public function getRemoteURI() {
	// Determine which remote to examine; default to 'origin'
	$remote = 'origin';
	$branch = $this->getBranchName();
	if ($branch) {
	$path = $this->getPathToUpstream($branch);
	if ($path->isConnectedToRemote()) {
	$remote = $path->getRemoteRemoteName();
	}
	}

	return $this->getGitRemoteFetchURI($remote);
	}

	public function getSourceControlPath() {
	// TODO: Try to get something useful here.
	return null;
	}

	public function getGitCommitLog() {
	$relative = $this->getBaseCommit();
	if ($this->repositoryHasNoCommits) {
	// No commits yet.
	return '';
	} else if ($relative == self::GIT_MAGIC_ROOT_COMMIT) {
	// First commit.
	list($stdout) = $this->execxLocal(
	- 'log --format=medium HEAD');
	+ 'log --format=medium HEAD --');
	} else {
	// 2..N commits.
	list($stdout) = $this->execxLocal(
	- 'log --first-parent --format=medium %s..%s',
	- $this->getBaseCommit(),
	- $this->getHeadCommit());
	+ 'log --first-parent --format=medium %s --',
	+ gitsprintf(
	+ '%s..%s',
	+ $this->getBaseCommit(),
	+ $this->getHeadCommit()));
	}
	return $stdout;
	}

	public function getGitHistoryLog() {
	list($stdout) = $this->execxLocal(
	- 'log --format=medium -n%d %s',
	+ 'log --format=medium -n%d %s --',
	self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
	- $this->getBaseCommit());
	+ gitsprintf('%s', $this->getBaseCommit()));
	return $stdout;
	}

	public function getSourceControlBaseRevision() {
	list($stdout) = $this->execxLocal(
	'rev-parse %s',
	$this->getBaseCommit());
	return rtrim($stdout, "\n");
	}

	public function getCanonicalRevisionName($string) {
	$match = null;

	if (preg_match('/@([0-9]+)$/', $string, $match)) {
	$stdout = $this->getHashFromFromSVNRevisionNumber($match[1]);
	} else {
	list($stdout) = $this->execxLocal(
	'show -s --format=%s %s --',
	'%H',
	$string);
	}

	return rtrim($stdout);
	}

	private function executeSVNFindRev($input, $vcs) {
	$match = array();
	list($stdout) = $this->execxLocal(
	'svn find-rev %s',
	$input);
	if (!$stdout) {
	throw new ArcanistUsageException(
	pht(
	'Cannot find the %s equivalent of %s.',
	$vcs,
	$input));
	}
	// When git performs a partial-rebuild during svn
	// look-up, we need to parse the final line
	$lines = explode("\n", $stdout);
	$stdout = $lines[count($lines) - 2];
	return rtrim($stdout);
	}

	// Convert svn revision number to git hash
	public function getHashFromFromSVNRevisionNumber($revision_id) {
	return $this->executeSVNFindRev('r'.$revision_id, 'Git');
	}


	// Convert a git hash to svn revision number
	public function getSVNRevisionNumberFromHash($hash) {
	return $this->executeSVNFindRev($hash, 'SVN');
	}

	private function buildUncommittedStatusViaStatus() {
	$status = $this->buildLocalFuture(
	array(
	'status --porcelain=2 -z',
	));
	list($stdout) = $status->resolvex();

	$result = new PhutilArrayWithDefaultValue();
	$parts = explode("\0", $stdout);
	while (count($parts) > 1) {
	$entry = array_shift($parts);
	$entry_parts = explode(' ', $entry, 2);
	if ($entry_parts[0] == '1') {
	$entry_parts = explode(' ', $entry, 9);
	$path = $entry_parts[8];
	} else if ($entry_parts[0] == '2') {
	$entry_parts = explode(' ', $entry, 10);
	$path = $entry_parts[9];
	} else if ($entry_parts[0] == 'u') {
	$entry_parts = explode(' ', $entry, 11);
	$path = $entry_parts[10];
	} else if ($entry_parts[0] == '?') {
	$entry_parts = explode(' ', $entry, 2);
	$result[$entry_parts[1]] = self::FLAG_UNTRACKED;
	continue;
	}

	$result[$path] \|= self::FLAG_UNCOMMITTED;
	$index_state = substr($entry_parts[1], 0, 1);
	$working_state = substr($entry_parts[1], 1, 1);
	if ($index_state == 'A') {
	$result[$path] \|= self::FLAG_ADDED;
	} else if ($index_state == 'M') {
	$result[$path] \|= self::FLAG_MODIFIED;
	} else if ($index_state == 'D') {
	$result[$path] \|= self::FLAG_DELETED;
	}
	if ($working_state != '.') {
	$result[$path] \|= self::FLAG_UNSTAGED;
	if ($index_state == '.') {
	if ($working_state == 'A') {
	$result[$path] \|= self::FLAG_ADDED;
	} else if ($working_state == 'M') {
	$result[$path] \|= self::FLAG_MODIFIED;
	} else if ($working_state == 'D') {
	$result[$path] \|= self::FLAG_DELETED;
	}
	}
	}
	$submodule_tracked = substr($entry_parts[2], 2, 1);
	$submodule_untracked = substr($entry_parts[2], 3, 1);
	if ($submodule_tracked == 'M' \|\| $submodule_untracked == 'U') {
	$result[$path] \|= self::FLAG_EXTERNALS;
	}

	if ($entry_parts[0] == '2') {
	$result[array_shift($parts)] = $result[$path] \| self::FLAG_DELETED;
	$result[$path] \|= self::FLAG_ADDED;
	}
	}
	return $result->toArray();
	}

	protected function buildUncommittedStatus() {
	if (version_compare($this->getGitVersion(), '2.11.0', '>=')) {
	return $this->buildUncommittedStatusViaStatus();
	}

	$diff_options = $this->getDiffBaseOptions();

	if ($this->repositoryHasNoCommits) {
	$diff_base = self::GIT_MAGIC_ROOT_COMMIT;
	} else {
	$diff_base = 'HEAD';
	}

	// Find uncommitted changes.
	$uncommitted_future = $this->buildLocalFuture(
	array(
	'diff %C --raw %s --',
	$diff_options,
	- $diff_base,
	+ gitsprintf('%s', $diff_base),
	));

	$untracked_future = $this->buildLocalFuture(
	array(
	'ls-files --others --exclude-standard',
	));

	// Unstaged changes
	$unstaged_future = $this->buildLocalFuture(
	array(
	'diff-files --name-only',
	));

	$futures = array(
	$uncommitted_future,
	$untracked_future,
	// NOTE: `git diff-files` races with each of these other commands
	// internally, and resolves with inconsistent results if executed
	// in parallel. To work around this, DO NOT run it at the same time.
	// After the other commands exit, we can start the `diff-files` command.
	);

	id(new FutureIterator($futures))->resolveAll();

	// We're clear to start the `git diff-files` now.
	$unstaged_future->start();

	$result = new PhutilArrayWithDefaultValue();

	list($stdout) = $uncommitted_future->resolvex();
	$uncommitted_files = $this->parseGitRawDiff($stdout);
	foreach ($uncommitted_files as $path => $mask) {
	$result[$path] \|= ($mask \| self::FLAG_UNCOMMITTED);
	}

	list($stdout) = $untracked_future->resolvex();
	$stdout = rtrim($stdout, "\n");
	if (strlen($stdout)) {
	$stdout = explode("\n", $stdout);
	foreach ($stdout as $path) {
	$result[$path] \|= self::FLAG_UNTRACKED;
	}
	}

	list($stdout, $stderr) = $unstaged_future->resolvex();
	$stdout = rtrim($stdout, "\n");
	if (strlen($stdout)) {
	$stdout = explode("\n", $stdout);
	foreach ($stdout as $path) {
	$result[$path] \|= self::FLAG_UNSTAGED;
	}
	}

	return $result->toArray();
	}

	protected function buildCommitRangeStatus() {
	list($stdout, $stderr) = $this->execxLocal(
	'diff %C --raw %s HEAD --',
	$this->getDiffBaseOptions(),
	- $this->getBaseCommit());
	+ gitsprintf('%s', $this->getBaseCommit()));

	return $this->parseGitRawDiff($stdout);
	}

	public function getGitConfig($key, $default = null) {
	list($err, $stdout) = $this->execManualLocal('config %s', $key);
	if ($err) {
	return $default;
	}
	return rtrim($stdout);
	}

	public function getAuthor() {
	list($stdout) = $this->execxLocal('var GIT_AUTHOR_IDENT');
	return preg_replace('/\s+<.*/', '', rtrim($stdout, "\n"));
	}

	public function addToCommit(array $paths) {
	$this->execxLocal(
	'add -A -- %Ls',
	$paths);
	$this->reloadWorkingCopy();
	return $this;
	}

	public function doCommit($message) {
	$tmp_file = new TempFile();
	Filesystem::writeFile($tmp_file, $message);

	// NOTE: "--allow-empty-message" was introduced some time after 1.7.0.4,
	// so we do not provide it and thus require a message.

	$this->execxLocal(
	'commit -F %s',
	$tmp_file);

	$this->reloadWorkingCopy();

	return $this;
	}

	public function amendCommit($message = null) {
	if ($message === null) {
	$this->execxLocal('commit --amend --allow-empty -C HEAD');
	} else {
	$tmp_file = new TempFile();
	Filesystem::writeFile($tmp_file, $message);
	$this->execxLocal(
	'commit --amend --allow-empty -F %s',
	$tmp_file);
	}

	$this->reloadWorkingCopy();
	return $this;
	}

	private function parseGitRawDiff($status, $full = false) {
	static $flags = array(
	'A' => self::FLAG_ADDED,
	'M' => self::FLAG_MODIFIED,
	'D' => self::FLAG_DELETED,
	);

	$status = trim($status);
	$lines = array();
	foreach (explode("\n", $status) as $line) {
	if ($line) {
	$lines[] = preg_split("/[ \t]/", $line, 6);
	}
	}

	$files = array();
	foreach ($lines as $line) {
	$mask = 0;

	// "git diff --raw" lines begin with a ":" character.
	$old_mode = ltrim($line[0], ':');
	$new_mode = $line[1];

	// The hashes may be padded with "." characters for alignment. Discard
	// them.
	$old_hash = rtrim($line[2], '.');
	$new_hash = rtrim($line[3], '.');

	$flag = $line[4];
	$file = $line[5];

	$new_value = intval($new_mode, 8);
	$is_submodule = (($new_value & 0160000) === 0160000);

	if (($is_submodule) &&
	($flag == 'M') &&
	($old_hash === $new_hash) &&
	($old_mode === $new_mode)) {
	// See T9455. We see this submodule as "modified", but the old and new
	// hashes are the same and the old and new modes are the same, so we
	// don't directly see a modification.

	// We can end up here if we have a submodule which has uncommitted
	// changes inside of it (for example, the user has added untracked
	// files or made uncommitted changes to files in the submodule). In
	// this case, we set a different flag because we can't meaningfully
	// give users the same prompt.

	// Note that if the submodule has real changes from the parent
	// perspective (the base commit has changed) and also has uncommitted
	// changes, we'll only see the real changes and miss the uncommitted
	// changes. At the time of writing, there is no reasonable porcelain
	// for finding those changes, and the impact of this error seems small.

	$mask \|= self::FLAG_EXTERNALS;
	} else if (isset($flags[$flag])) {
	$mask \|= $flags[$flag];
	} else if ($flag[0] == 'R') {
	$both = explode("\t", $file);
	if ($full) {
	$files[$both[0]] = array(
	'mask' => $mask \| self::FLAG_DELETED,
	'ref' => str_repeat('0', 40),
	);
	} else {
	$files[$both[0]] = $mask \| self::FLAG_DELETED;
	}
	$file = $both[1];
	$mask \|= self::FLAG_ADDED;
	} else if ($flag[0] == 'C') {
	$both = explode("\t", $file);
	$file = $both[1];
	$mask \|= self::FLAG_ADDED;
	}

	if ($full) {
	$files[$file] = array(
	'mask' => $mask,
	'ref' => $new_hash,
	);
	} else {
	$files[$file] = $mask;
	}
	}

	return $files;
	}

	public function getAllFiles() {
	$future = $this->buildLocalFuture(array('ls-files -z'));
	return id(new LinesOfALargeExecFuture($future))
	->setDelimiter("\0");
	}

	public function getChangedFiles($since_commit) {
	list($stdout) = $this->execxLocal(
	- 'diff --raw %s',
	- $since_commit);
	+ 'diff --raw %s --',
	+ gitsprintf('%s', $since_commit));
	return $this->parseGitRawDiff($stdout);
	}

	public function getBlame($path) {
	list($stdout) = $this->execxLocal(
	'blame --porcelain -w -M %s -- %s',
	- $this->getBaseCommit(),
	+ gitsprintf('%s', $this->getBaseCommit()),
	$path);

	// the --porcelain format prints at least one header line per source line,
	// then the source line prefixed by a tab character
	$blame_info = preg_split('/^\t.*\n/m', rtrim($stdout));

	// commit info is not repeated in these headers, so cache it
	$revision_data = array();

	$blame = array();
	foreach ($blame_info as $line_info) {
	$revision = substr($line_info, 0, 40);
	$data = idx($revision_data, $revision, array());

	if (empty($data)) {
	$matches = array();
	if (!preg_match('/^author (.*)$/m', $line_info, $matches)) {
	throw new Exception(
	pht(
	'Unexpected output from %s: no author for commit %s',
	'git blame',
	$revision));
	}
	$data['author'] = $matches[1];
	$data['from_first_commit'] = preg_match('/^boundary$/m', $line_info);
	$revision_data[$revision] = $data;
	}

	// Ignore lines predating the git repository (on a boundary commit)
	// rather than blaming them on the oldest diff's unfortunate author
	if (!$data['from_first_commit']) {
	$blame[] = array($data['author'], $revision);
	}
	}

	return $blame;
	}

	public function getOriginalFileData($path) {
	return $this->getFileDataAtRevision($path, $this->getBaseCommit());
	}

	public function getCurrentFileData($path) {
	return $this->getFileDataAtRevision($path, 'HEAD');
	}

	private function parseGitTree($stdout) {
	$result = array();

	$stdout = trim($stdout);
	if (!strlen($stdout)) {
	return $result;
	}

	$lines = explode("\n", $stdout);
	foreach ($lines as $line) {
	$matches = array();
	$ok = preg_match(
	'/^(\d{6}) (blob\|tree\|commit) ([a-z0-9]{40})[\t](.*)$/',
	$line,
	$matches);
	if (!$ok) {
	throw new Exception(pht('Failed to parse %s output!', 'git ls-tree'));
	}
	$result[$matches[4]] = array(
	'mode' => $matches[1],
	'type' => $matches[2],
	'ref' => $matches[3],
	);
	}
	return $result;
	}

	private function getFileDataAtRevision($path, $revision) {
	// NOTE: We don't want to just "git show {$revision}:{$path}" since if the
	// path was a directory at the given revision we'll get a list of its files
	// and treat it as though it as a file containing a list of other files,
	// which is silly.

	if (!strlen($path)) {
	// No filename, so there's no content (Probably new/deleted file).
	return null;
	}

	list($stdout) = $this->execxLocal(
	'ls-tree %s -- %s',
	- $revision,
	+ gitsprintf('%s', $revision),
	$path);

	$info = $this->parseGitTree($stdout);
	if (empty($info[$path])) {
	// No such path, or the path is a directory and we executed 'ls-tree dir/'
	// and got a list of its contents back.
	return null;
	}

	if ($info[$path]['type'] != 'blob') {
	// Path is or was a directory, not a file.
	return null;
	}

	list($stdout) = $this->execxLocal(
	- 'cat-file blob %s',
	+ 'cat-file blob -- %s',
	$info[$path]['ref']);
	return $stdout;
	}

	/**
	* Returns names of all the branches in the current repository.
	*
	* @return list<dict<string, string>> Dictionary of branch information.
	*/
	private function getAllBranches() {
	$field_list = array(
	'%(refname)',
	'%(objectname)',
	'%(committerdate:raw)',
	'%(tree)',
	'%(subject)',
	'%(subject)%0a%0a%(body)',
	'%02',
	);

	list($stdout) = $this->execxLocal(
	'for-each-ref --format=%s -- refs/heads',
	implode('%01', $field_list));

	$current = $this->getBranchName();
	$result = array();

	$lines = explode("\2", $stdout);
	foreach ($lines as $line) {
	$line = trim($line);
	if (!strlen($line)) {
	continue;
	}

	$fields = explode("\1", $line, 6);
	list($ref, $hash, $epoch, $tree, $desc, $text) = $fields;

	$branch = $this->getBranchNameFromRef($ref);
	if ($branch !== null) {
	$result[] = array(
	'current' => ($branch === $current),
	'name' => $branch,
	'ref' => $ref,
	'hash' => $hash,
	'tree' => $tree,
	'epoch' => (int)$epoch,
	'desc' => $desc,
	'text' => $text,
	);
	}
	}

	return $result;
	}

	public function getBaseCommitRef() {
	$base_commit = $this->getBaseCommit();

	if ($base_commit === self::GIT_MAGIC_ROOT_COMMIT) {
	return null;
	}

	$base_message = $this->getCommitMessage($base_commit);

	// TODO: We should also pull the tree hash.

	return $this->newCommitRef()
	->setCommitHash($base_commit)
	->attachMessage($base_message);
	}

	public function getWorkingCopyRevision() {
	list($stdout) = $this->execxLocal('rev-parse HEAD');
	return rtrim($stdout, "\n");
	}

	public function isHistoryDefaultImmutable() {
	return false;
	}

	public function supportsAmend() {
	return true;
	}

	public function supportsCommitRanges() {
	return true;
	}

	public function supportsLocalCommits() {
	return true;
	}

	public function hasLocalCommit($commit) {
	try {
	if (!$this->getCanonicalRevisionName($commit)) {
	return false;
	}
	} catch (CommandException $exception) {
	return false;
	}
	return true;
	}

	public function getAllLocalChanges() {
	$diff = $this->getFullGitDiff($this->getBaseCommit());
	if (!strlen(trim($diff))) {
	return array();
	}
	$parser = new ArcanistDiffParser();
	return $parser->parseDiff($diff);
	}

	public function getFinalizedRevisionMessage() {
	return pht(
	"You may now push this commit upstream, as appropriate (e.g. with ".
	"'%s', or '%s', or by printing and faxing it).",
	'git push',
	'git svn dcommit');
	}

	public function getCommitMessage($commit) {
	list($message) = $this->execxLocal(
	'log -n1 --format=%C %s --',
	'%s%n%n%b',
	- $commit);
	+ gitsprintf('%s', $commit));
	return $message;
	}

	public function loadWorkingCopyDifferentialRevisions(
	ConduitClient $conduit,
	array $query) {

	$messages = $this->getGitCommitLog();
	if (!strlen($messages)) {
	return array();
	}

	$parser = new ArcanistDiffParser();
	$messages = $parser->parseDiff($messages);

	// First, try to find revisions by explicit revision IDs in commit messages.
	$reason_map = array();
	$revision_ids = array();
	foreach ($messages as $message) {
	$object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
	$message->getMetadata('message'));
	if ($object->getRevisionID()) {
	$revision_ids[] = $object->getRevisionID();
	$reason_map[$object->getRevisionID()] = $message->getCommitHash();
	}
	}

	if ($revision_ids) {
	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'ids' => $revision_ids,
	));

	foreach ($results as $key => $result) {
	$hash = substr($reason_map[$result['id']], 0, 16);
	$results[$key]['why'] = pht(
	"Commit message for '%s' has explicit 'Differential Revision'.",
	$hash);
	}

	return $results;
	}

	// If we didn't succeed, try to find revisions by hash.
	$hashes = array();
	foreach ($this->getLocalCommitInformation() as $commit) {
	$hashes[] = array('gtcm', $commit['commit']);
	$hashes[] = array('gttr', $commit['tree']);
	}

	$results = $conduit->callMethodSynchronous(
	'differential.query',
	$query + array(
	'commitHashes' => $hashes,
	));

	foreach ($results as $key => $result) {
	$results[$key]['why'] = pht(
	'A git commit or tree hash in the commit range is already attached '.
	'to the Differential revision.');
	}

	return $results;
	}

	public function updateWorkingCopy() {
	$this->execxLocal('pull');
	$this->reloadWorkingCopy();
	}

	public function getCommitSummary($commit) {
	if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
	return pht('(The Empty Tree)');
	}

	list($summary) = $this->execxLocal(
	- 'log -n 1 --format=%C %s',
	- '%s',
	- $commit);
	+ 'log -n 1 %s %s --',
	+ '--format=%s',
	+ gitsprintf('%s', $commit));

	return trim($summary);
	}

	public function isGitSubversionRepo() {
	return Filesystem::pathExists($this->getPath('.git/svn'));
	}

	public function resolveBaseCommitRule($rule, $source) {
	list($type, $name) = explode(':', $rule, 2);

	switch ($type) {
	case 'git':
	$matches = null;
	if (preg_match('/^merge-base$(.+)$$/', $name, $matches)) {
	list($err, $merge_base) = $this->execManualLocal(
	- 'merge-base %s HEAD',
	+ 'merge-base -- %s HEAD',
	$matches[1]);
	if (!$err) {
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of '%s' and HEAD, as specified by ".
	"'%s' in your %s 'base' configuration.",
	$matches[1],
	$rule,
	$source));
	return trim($merge_base);
	}
	} else if (preg_match('/^branch-unique$(.+)$$/', $name, $matches)) {
	list($err, $merge_base) = $this->execManualLocal(
	- 'merge-base %s HEAD',
	+ 'merge-base -- %s HEAD',
	$matches[1]);
	if ($err) {
	return null;
	}
	$merge_base = trim($merge_base);

	list($commits) = $this->execxLocal(
	'log --format=%C %s..HEAD --',
	'%H',
	$merge_base);
	$commits = array_filter(explode("\n", $commits));

	if (!$commits) {
	return null;
	}

	$commits[] = $merge_base;

	$head_branch_count = null;
	$all_branch_names = ipull($this->getAllBranches(), 'name');
	foreach ($commits as $commit) {
	// Ideally, we would use something like "for-each-ref --contains"
	// to get a filtered list of branches ready for script consumption.
	// Instead, try to get predictable output from "branch --contains".

	$flags = array();
	$flags[] = '--no-color';

	// NOTE: The "--no-column" flag was introduced in Git 1.7.11, so
	// don't pass it if we're running an older version. See T9953.
	$version = $this->getGitVersion();
	if (version_compare($version, '1.7.11', '>=')) {
	$flags[] = '--no-column';
	}

	list($branches) = $this->execxLocal(
	'branch %Ls --contains %s',
	$flags,
	$commit);
	$branches = array_filter(explode("\n", $branches));

	// Filter the list, removing the "current" marker (*) and ignoring
	// anything other than known branch names (mainly, any possible
	// "detached HEAD" or "no branch" line).
	foreach ($branches as $key => $branch) {
	$branch = trim($branch, ' *');
	if (in_array($branch, $all_branch_names)) {
	$branches[$key] = $branch;
	} else {
	unset($branches[$key]);
	}
	}

	if ($head_branch_count === null) {
	// If this is the first commit, it's HEAD. Count how many
	// branches it is on; we want to include commits on the same
	// number of branches. This covers a case where this branch
	// has sub-branches and we're running "arc diff" here again
	// for whatever reason.
	$head_branch_count = count($branches);
	} else if (count($branches) > $head_branch_count) {
	$branches = implode(', ', $branches);
	$this->setBaseCommitExplanation(
	pht(
	"it is the first commit between '%s' (the merge-base of ".
	"'%s' and HEAD) which is also contained by another branch ".
	"(%s).",
	$merge_base,
	$matches[1],
	$branches));
	return $commit;
	}
	}
	} else {
	list($err) = $this->execManualLocal(
	'cat-file -t %s',
	$name);
	if (!$err) {
	$this->setBaseCommitExplanation(
	pht(
	"it is specified by '%s' in your %s 'base' configuration.",
	$rule,
	$source));
	return $name;
	}
	}
	break;
	case 'arc':
	switch ($name) {
	case 'empty':
	$this->setBaseCommitExplanation(
	pht(
	"you specified '%s' in your %s 'base' configuration.",
	$rule,
	$source));
	return self::GIT_MAGIC_ROOT_COMMIT;
	case 'amended':
	$text = $this->getCommitMessage('HEAD');
	$message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
	$text);
	if ($message->getRevisionID()) {
	$this->setBaseCommitExplanation(
	pht(
	"HEAD has been amended with 'Differential Revision:', ".
	"as specified by '%s' in your %s 'base' configuration.",
	$rule,
	$source));
	return 'HEAD^';
	}
	break;
	case 'upstream':
	list($err, $upstream) = $this->execManualLocal(
	'rev-parse --abbrev-ref --symbolic-full-name %s',
	'@{upstream}');
	if (!$err) {
	$upstream = rtrim($upstream);
	list($upstream_merge_base) = $this->execxLocal(
	- 'merge-base %s HEAD',
	+ 'merge-base -- %s HEAD',
	$upstream);
	$upstream_merge_base = rtrim($upstream_merge_base);
	$this->setBaseCommitExplanation(
	pht(
	"it is the merge-base of the upstream of the current branch ".
	"and HEAD, and matched the rule '%s' in your %s ".
	"'base' configuration.",
	$rule,
	$source));
	return $upstream_merge_base;
	}
	break;
	case 'this':
	$this->setBaseCommitExplanation(
	pht(
	"you specified '%s' in your %s 'base' configuration.",
	$rule,
	$source));
	return 'HEAD^';
	}
	default:
	return null;
	}

	return null;
	}

	public function canStashChanges() {
	return true;
	}

	public function stashChanges() {
	$this->execxLocal('stash');
	$this->reloadWorkingCopy();
	}

	public function unstashChanges() {
	$this->execxLocal('stash pop');
	}

	protected function didReloadCommitRange() {
	// After an amend, the symbolic head may resolve to a different commit.
	$this->resolvedHeadCommit = null;
	}

	/**
	* Follow the chain of tracking branches upstream until we reach a remote
	* or cycle locally.
	*
	* @param string Ref to start from.
	* @return ArcanistGitUpstreamPath Path to an upstream.
	*/
	public function getPathToUpstream($start) {
	$cursor = $start;
	$path = new ArcanistGitUpstreamPath();
	while (true) {
	list($err, $upstream) = $this->execManualLocal(
	'rev-parse --symbolic-full-name %s@{upstream}',
	$cursor);

	if ($err) {
	// We ended up somewhere with no tracking branch, so we're done.
	break;
	}

	$upstream = trim($upstream);

	if (preg_match('(^refs/heads/)', $upstream)) {
	$upstream = preg_replace('(^refs/heads/)', '', $upstream);

	$is_cycle = $path->getUpstream($upstream);

	$path->addUpstream(
	$cursor,
	array(
	'type' => ArcanistGitUpstreamPath::TYPE_LOCAL,
	'name' => $upstream,
	'cycle' => $is_cycle,
	));

	if ($is_cycle) {
	// We ran into a local cycle, so we're done.
	break;
	}

	// We found another local branch, so follow that one upriver.
	$cursor = $upstream;
	continue;
	}

	if (preg_match('(^refs/remotes/)', $upstream)) {
	$upstream = preg_replace('(^refs/remotes/)', '', $upstream);
	list($remote, $branch) = explode('/', $upstream, 2);

	$path->addUpstream(
	$cursor,
	array(
	'type' => ArcanistGitUpstreamPath::TYPE_REMOTE,
	'name' => $branch,
	'remote' => $remote,
	));

	// We found a remote, so we're done.
	break;
	}

	throw new Exception(
	pht(
	'Got unrecognized upstream format ("%s") from Git, expected '.
	'"refs/heads/..." or "refs/remotes/...".',
	$upstream));
	}

	return $path;
	}

	public function isPerforceRemote($remote_name) {
	// See T13434. In Perforce workflows, "git p4 clone" creates "p4" refs
	// under "refs/remotes/", but does not define a real remote named "p4".

	// We treat this remote as though it were a real remote during "arc land",
	// but it does not respond to commands like "git remote show p4", so we
	// need to handle it specially.

	if ($remote_name !== 'p4') {
	return false;
	}

	$remote_dir = $this->getMetadataPath().'/refs/remotes/p4';
	if (!Filesystem::pathExists($remote_dir)) {
	return false;
	}

	return true;
	}

	public function isPushableRemote($remote_name) {
	$uri = $this->getGitRemotePushURI($remote_name);
	return ($uri !== null);
	}

	public function isFetchableRemote($remote_name) {
	$uri = $this->getGitRemoteFetchURI($remote_name);
	return ($uri !== null);
	}

	private function getGitRemoteFetchURI($remote_name) {
	return $this->getGitRemoteURI($remote_name, $for_push = false);
	}

	private function getGitRemotePushURI($remote_name) {
	return $this->getGitRemoteURI($remote_name, $for_push = true);
	}

	private function getGitRemoteURI($remote_name, $for_push) {
	$remote_uri = $this->loadGitRemoteURI($remote_name, $for_push);

	if ($remote_uri !== null) {
	$remote_uri = rtrim($remote_uri);
	if (!strlen($remote_uri)) {
	$remote_uri = null;
	}
	}

	return $remote_uri;
	}

	private function loadGitRemoteURI($remote_name, $for_push) {
	// Try to identify the best URI for a given remote. This is complicated
	// because remotes may have different "push" and "fetch" URIs, may
	// rewrite URIs with "insteadOf" configuration, and different versions
	// of Git support different URI resolution commands.

	// Remotes may also have more than one URI of a given type, but we ignore
	// those cases here.

	// Start with "git remote get-url [--push]". This is the simplest and
	// most accurate command, but was introduced most recently in Git's
	// history.

	$argv = array();
	if ($for_push) {
	$argv[] = '--push';
	}

	list($err, $stdout) = $this->execManualLocal(
	'remote get-url %Ls -- %s',
	$argv,
	$remote_name);
	if (!$err) {
	return $stdout;
	}

	// See T13481. If "git remote get-url [--push]" failed, it might be because
	// the remote does not exist, but it might also be because the version of
	// Git is too old to support "git remote get-url", which was introduced
	// in Git 2.7 (circa late 2015).

	$git_version = $this->getGitVersion();
	if (version_compare($git_version, '2.7', '>=')) {
	// This version of Git should support "git remote get-url --push", but
	// the command failed, so conclude this is not a valid remote and thus
	// there is no remote URI.
	return null;
	}

	// If we arrive here, we're in a version of Git which is too old to
	// support "git remote get-url [--push]". We're going to fall back to
	// older and less accurate mechanisms for figuring out the remote URI.

	// The first mechanism we try is "git ls-remote --get-url". This exists
	// in Git 1.7.5 or newer. It only gives us the fetch URI, so this result
	// will be incorrect if a remote has different fetch and push URIs.
	// However, this is very rare, and this result is almost always correct.

	// Note that some old versions of Git do not parse "--" in this command
	// properly. We omit it since it doesn't seem like there's anything
	// dangerous an attacker can do even if they can choose a remote name to
	// intentionally cause an argument misparse.

	// This will cause the command to behave incorrectly for remotes with
	// names which are also valid flags, like "--quiet".

	list($err, $stdout) = $this->execManualLocal(
	'ls-remote --get-url %s',
	$remote_name);
	if (!$err) {
	// The "git ls-remote --get-url" command just echoes the remote name
	// (like "origin") if no remote URI is found. Treat this like a failure.
	$output_is_input = (rtrim($stdout) === $remote_name);
	if (!$output_is_input) {
	return $stdout;
	}
	}

	if (version_compare($git_version, '1.7.5', '>=')) {
	// This version of Git should support "git ls-remote --get-url", but
	// the command failed (or echoed the input), so conclude the remote
	// really does not exist.
	return null;
	}

	// Fall back to the very old "git config -- remote.origin.url" command.
	// This does not give us push URLs and does not resolve "insteadOf"
	// aliases, but still works in the simplest (and most common) cases.

	list($err, $stdout) = $this->execManualLocal(
	'config -- %s',
	sprintf('remote.%s.url', $remote_name));
	if (!$err) {
	return $stdout;
	}

	return null;
	}

	protected function newCurrentCommitSymbol() {
	return 'HEAD';
	}

	public function isGitLFSWorkingCopy() {

	// We're going to run:
	//
	// $ git ls-files -z -- ':(attr:filter=lfs)'
	//
	// ...and exit as soon as it generates any field terminated with a "\0".
	//
	// If this command generates any such output, that means this working copy
	// contains at least one LFS file, so it's an LFS working copy. If it
	// exits with no error and no output, this is not an LFS working copy.
	//
	// If it exits with an error, we're in trouble.

	$future = $this->buildLocalFuture(
	array(
	'ls-files -z -- %s',
	':(attr:filter=lfs)',
	));

	$lfs_list = id(new LinesOfALargeExecFuture($future))
	->setDelimiter("\0");

	try {
	foreach ($lfs_list as $lfs_file) {
	// We have our answer, so we can throw the subprocess away.
	$future->resolveKill();
	return true;
	}
	return false;
	} catch (CommandException $ex) {
	// This is probably an older version of Git. Continue below.
	}

	// In older versions of Git, the first command will fail with an error
	// ("Invalid pathspec magic..."). See PHI1718.
	//
	// Some other tests we could use include:
	//
	// (1) Look for ".gitattributes" at the repository root. This approach is
	// a rough approximation because ".gitattributes" may be global or in a
	// subdirectory. See D21190.
	//
	// (2) Use "git check-attr" and pipe a bunch of files into it, roughly
	// like this:
	//
	// $ git ls-files -z -- \| git check-attr --stdin -z filter --
	//
	// However, the best version of this check I could come up with is fairly
	// slow in even moderately large repositories (~200ms in a repository with
	// 10K paths). See D21190.
	//
	// (3) Use "git lfs ls-files". This is even worse than piping "ls-files"
	// to "check-attr" in PHP (~600ms in a repository with 10K paths).
	//
	// (4) Give up and just assume the repository isn't LFS. This is the
	// current behavior.

	return false;
	}

	protected function newLandEngine() {
	return new ArcanistGitLandEngine();
	}

	protected function newWorkEngine() {
	return new ArcanistGitWorkEngine();
	}

	public function newLocalState() {
	return id(new ArcanistGitLocalState())
	->setRepositoryAPI($this);
	}

	public function readRawCommit($hash) {
	list($stdout) = $this->execxLocal(
	'cat-file commit -- %s',
	$hash);

	return ArcanistGitRawCommit::newFromRawBlob($stdout);
	}

	public function writeRawCommit(ArcanistGitRawCommit $commit) {
	$blob = $commit->getRawBlob();

	$future = $this->execFutureLocal('hash-object -t commit --stdin -w');
	$future->write($blob);
	list($stdout) = $future->resolvex();

	return trim($stdout);
	}

	protected function newSupportedMarkerTypes() {
	return array(
	ArcanistMarkerRef::TYPE_BRANCH,
	);
	}

	protected function newMarkerRefQueryTemplate() {
	return new ArcanistGitRepositoryMarkerQuery();
	}

	protected function newRemoteRefQueryTemplate() {
	return new ArcanistGitRepositoryRemoteQuery();
	}

	protected function newNormalizedURI($uri) {
	return new ArcanistRepositoryURINormalizer(
	ArcanistRepositoryURINormalizer::TYPE_GIT,
	$uri);
	}

	protected function newPublishedCommitHashes() {
	$remotes = $this->newRemoteRefQuery()
	->execute();
	if (!$remotes) {
	return array();
	}

	$markers = $this->newMarkerRefQuery()
	->withIsRemoteCache(true)
	->execute();

	if (!$markers) {
	return array();
	}

	$runtime = $this->getRuntime();
	$workflow = $runtime->getCurrentWorkflow();

	$workflow->loadHardpoints(
	$remotes,
	ArcanistRemoteRef::HARDPOINT_REPOSITORYREFS);

	$remotes = mpull($remotes, null, 'getRemoteName');

	$hashes = array();

	foreach ($markers as $marker) {
	$remote_name = $marker->getRemoteName();
	$remote = idx($remotes, $remote_name);
	if (!$remote) {
	continue;
	}

	if (!$remote->isPermanentRef($marker)) {
	continue;
	}

	$hashes[] = $marker->getCommitHash();
	}

	return $hashes;
	}

	protected function newCommitGraphQueryTemplate() {
	return new ArcanistGitCommitGraphQuery();
	}

	}
	diff --git a/src/repository/graph/query/ArcanistGitCommitGraphQuery.php b/src/repository/graph/query/ArcanistGitCommitGraphQuery.php
	index 53587e45..32a3a08e 100644
	--- a/src/repository/graph/query/ArcanistGitCommitGraphQuery.php
	+++ b/src/repository/graph/query/ArcanistGitCommitGraphQuery.php
	@@ -1,209 +1,209 @@
	<?php

	final class ArcanistGitCommitGraphQuery
	extends ArcanistCommitGraphQuery {

	private $seen = array();
	private $futures = array();
	private $iterators = array();
	private $cursors = array();
	private $iteratorKey = 0;

	public function execute() {
	$this->newFutures();

	$this->executeIterators();

	return $this->seen;
	}

	private function newFutures() {
	$head_hashes = $this->getHeadHashes();
	$exact_hashes = $this->getExactHashes();

	if (!$head_hashes && !$exact_hashes) {
	throw new Exception(pht('Need head hashes or exact hashes!'));
	}

	$api = $this->getRepositoryAPI();
	$ref_lists = array();

	if ($head_hashes) {
	$refs = array();
	if ($head_hashes !== null) {
	foreach ($head_hashes as $hash) {
	$refs[] = $hash;
	}
	}

	$tail_hashes = $this->getTailHashes();
	if ($tail_hashes !== null) {
	foreach ($tail_hashes as $tail_hash) {
	$refs[] = sprintf('^%s^@', $tail_hash);
	}
	}

	$ref_lists[] = $refs;
	}

	if ($exact_hashes !== null) {
	foreach ($exact_hashes as $exact_hash) {
	$ref_list = array();
	$ref_list[] = $exact_hash;
	$ref_list[] = sprintf('^%s^@', $exact_hash);
	$ref_list[] = '--';
	$ref_lists[] = $ref_list;
	}
	}

	$flags = array();

	$min_epoch = $this->getMinimumEpoch();
	if ($min_epoch !== null) {
	$flags[] = '--after';
	$flags[] = date('c', $min_epoch);
	}

	$max_epoch = $this->getMaximumEpoch();
	if ($max_epoch !== null) {
	$flags[] = '--before';
	$flags[] = date('c', $max_epoch);
	}

	foreach ($ref_lists as $ref_list) {
	$ref_blob = implode("\n", $ref_list)."\n";

	$fields = array(
	'%e',
	'%H',
	'%P',
	'%ct',
	'%B',
	);

	$format = implode('%x02', $fields).'%x01';

	$future = $api->newFuture(
	- 'log --format=%s %Ls --stdin',
	+ 'log --format=%s %Ls --stdin --',
	$format,
	$flags);
	$future->write($ref_blob);
	$future->setResolveOnError(true);

	$this->futures[] = $future;
	}
	}

	private function executeIterators() {
	while ($this->futures \|\| $this->iterators) {
	$iterator_limit = 8;

	while (count($this->iterators) < $iterator_limit) {
	if (!$this->futures) {
	break;
	}

	$future = array_pop($this->futures);
	$future->start();

	$iterator = id(new LinesOfALargeExecFuture($future))
	->setDelimiter("\1");
	$iterator->rewind();

	$iterator_key = $this->getNextIteratorKey();
	$this->iterators[$iterator_key] = $iterator;
	}

	$limit = $this->getLimit();

	foreach ($this->iterators as $iterator_key => $iterator) {
	$this->executeIterator($iterator_key, $iterator);

	if ($limit) {
	if (count($this->seen) >= $limit) {
	return;
	}
	}
	}
	}
	}

	private function getNextIteratorKey() {
	return $this->iteratorKey++;
	}

	private function executeIterator($iterator_key, $lines) {
	$graph = $this->getGraph();
	$limit = $this->getLimit();

	$is_done = false;

	while (true) {
	if (!$lines->valid()) {
	$is_done = true;
	break;
	}

	$line = $lines->current();
	$lines->next();

	if ($line === "\n") {
	continue;
	}

	$fields = explode("\2", $line);

	if (count($fields) !== 5) {
	throw new Exception(
	pht(
	'Failed to split line "%s" from "git log".',
	$line));
	}

	list($encoding, $hash, $parents, $commit_epoch, $message) = $fields;

	// TODO: Handle encoding, see DiffusionLowLevelCommitQuery.

	$node = $graph->getNode($hash);
	if (!$node) {
	$node = $graph->newNode($hash);
	}

	$this->seen[$hash] = $node;

	$node
	->setCommitMessage($message)
	->setCommitEpoch((int)$commit_epoch);

	if (strlen($parents)) {
	$parents = explode(' ', $parents);

	$parent_nodes = array();
	foreach ($parents as $parent) {
	$parent_node = $graph->getNode($parent);
	if (!$parent_node) {
	$parent_node = $graph->newNode($parent);
	}

	$parent_nodes[$parent] = $parent_node;
	$parent_node->addChildNode($node);

	}
	$node->setParentNodes($parent_nodes);
	} else {
	$parents = array();
	}

	if ($limit) {
	if (count($this->seen) >= $limit) {
	break;
	}
	}
	}

	if ($is_done) {
	unset($this->iterators[$iterator_key]);
	}
	}

	}
	diff --git a/src/xsprintf/__tests__/PhutilGitsprintfTestCase.php b/src/xsprintf/__tests__/PhutilGitsprintfTestCase.php
	new file mode 100644
	index 00000000..493b887b
	--- /dev/null
	+++ b/src/xsprintf/__tests__/PhutilGitsprintfTestCase.php
	@@ -0,0 +1,40 @@
	+<?php
	+
	+final class PhutilGitsprintfTestCase extends PhutilTestCase {
	+
	+ public function testHgsprintf() {
	+ $selectors = array(
	+ 'HEAD' => 'HEAD',
	+ 'master' => 'master',
	+ 'a..b' => 'a..b',
	+ 'feature^' => 'feature^',
	+ '--flag' => false,
	+ );
	+
	+ foreach ($selectors as $input => $expect) {
	+ $caught = null;
	+
	+ try {
	+ $output = gitsprintf('%s', $input);
	+ } catch (Exception $ex) {
	+ $caught = $ex;
	+ } catch (Throwable $ex) {
	+ $caught = $ex;
	+ }
	+
	+ if ($caught !== null) {
	+ $actual = false;
	+ } else {
	+ $actual = $output;
	+ }
	+
	+ $this->assertEqual(
	+ $expect,
	+ $actual,
	+ pht(
	+ 'Result for input "%s".',
	+ $input));
	+ }
	+ }
	+
	+}
	diff --git a/src/xsprintf/gitsprintf.php b/src/xsprintf/gitsprintf.php
	new file mode 100644
	index 00000000..73a85ecd
	--- /dev/null
	+++ b/src/xsprintf/gitsprintf.php
	@@ -0,0 +1,64 @@
	+<?php
	+
	+/**
	+ * Format a Git ref selector. This formatting is important when executing
	+ * commands like "git log" which can not unambiguously parse all values as
	+ * ref selectors.
	+ *
	+ * Supports the following conversions:
	+ *
	+ * %s Ref Selector
	+ * Escapes a Git ref selector. In particular, this will reject ref selectors
	+ * which Git may interpret as flags.
	+ *
	+ * %R Raw String
	+ * Passes text through unescaped.
	+ */
	+function gitsprintf($pattern /* , ... */) {
	+ $args = func_get_args();
	+ return xsprintf('xsprintf_git', null, $args);
	+}
	+
	+/**
	+ * @{function:xsprintf} callback for Git encoding.
	+ */
	+function xsprintf_git($userdata, &$pattern, &$pos, &$value, &$length) {
	+ $type = $pattern[$pos];
	+
	+ switch ($type) {
	+ case 's':
	+
	+ // See T13589. Some Git commands accept both a ref selector and a list of
	+ // paths. For example:
	+
	+ // $ git log <ref> -- <path> <path> ...
	+
	+ // These commands disambiguate ref selectors from paths using "--", but
	+ // have no mechanism for disambiguating ref selectors from flags.
	+
	+ // Thus, there appears to be no way (in the general case) to safely
	+ // invoke these commands with an arbitrary ref selector string: ref
	+ // selector strings like "--flag" may be interpreted as flags, not as
	+ // ref selectors.
	+
	+ // To resolve this, we reject any ref selector which begins with "-".
	+ // These selectors are never valid anyway, so there is no loss of overall
	+ // correctness. It would be more desirable to pass them to Git in a way
	+ // that guarantees Git inteprets the string as a ref selector, but it
	+ // appears that no mechanism exists to allow this.
	+
	+ if (preg_match('(^-)', $value)) {
	+ throw new Exception(
	+ pht(
	+ 'Git ref selector "%s" is not a valid selector and can not be '.
	+ 'passed to the Git CLI safely in the general case.',
	+ $value));
	+ }
	+ break;
	+ case 'R':
	+ $type = 's';
	+ break;
	+ }
	+
	+ $pattern[$pos] = $type;
	+}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jan 24, 10:11 (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 601589
Default Alt Text: (258 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions