diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
index 9ddfbbe0..7bf922b9 100644
--- a/src/__phutil_library_map__.php
+++ b/src/__phutil_library_map__.php
@@ -1,1965 +1,1937 @@
 <?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',
     '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',
     'ArcanistConduitCall' => 'conduit/ArcanistConduitCall.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',
-    'ArcanistDisplayRef' => 'ref/ArcanistDisplayRef.php',
-    'ArcanistDisplayRefInterface' => 'ref/ArcanistDisplayRefInterface.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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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',
     '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_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_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' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    'ArcanistBuildPlanRef' => 'ArcanistRef',
     'ArcanistBuildPlanSymbolRef' => 'ArcanistSimpleSymbolRef',
-    'ArcanistBuildRef' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    'ArcanistBuildRef' => 'ArcanistRef',
     'ArcanistBuildSymbolRef' => 'ArcanistSimpleSymbolRef',
     'ArcanistBuildableBuildsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
-    'ArcanistBuildableRef' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    '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',
     'ArcanistCommitRef' => 'ArcanistRef',
     'ArcanistCommitSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistCommitSymbolRefInspector' => 'ArcanistRefInspector',
     'ArcanistCommitUpstreamHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistComposerLinter' => 'ArcanistLinter',
     'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistConduitCall' => 'Phobject',
     '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',
-    'ArcanistDisplayRef' => array(
-      'Phobject',
-      'ArcanistTerminalStringInterface',
-    ),
     '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' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    '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',
     'ArcanistGitCommitMessageHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGitLandEngine' => 'ArcanistLandEngine',
     'ArcanistGitLocalState' => 'ArcanistRepositoryLocalState',
     'ArcanistGitRawCommit' => 'Phobject',
     'ArcanistGitRawCommitTestCase' => 'PhutilTestCase',
     'ArcanistGitRepositoryMarkerQuery' => 'ArcanistRepositoryMarkerQuery',
     'ArcanistGitUpstreamPath' => 'Phobject',
     'ArcanistGitWorkEngine' => 'ArcanistWorkEngine',
     'ArcanistGitWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
     'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
     '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',
     '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',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
-    'ArcanistMarkerRef' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    'ArcanistMarkerRef' => 'ArcanistRef',
     'ArcanistMarkersWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
     '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' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    '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',
     'ArcanistRepositoryAPI' => 'Phobject',
     'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryLocalState' => 'Phobject',
     'ArcanistRepositoryMarkerQuery' => 'ArcanistRepositoryQuery',
     'ArcanistRepositoryQuery' => 'Phobject',
     'ArcanistRepositoryRef' => 'ArcanistRef',
     'ArcanistRepositoryRemoteQuery' => 'ArcanistRepositoryQuery',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRevisionAuthorHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionBuildableHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionCommitMessageHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionParentRevisionsHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
-    'ArcanistRevisionRef' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    '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',
     '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' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    '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' => array(
-      'ArcanistRef',
-      'ArcanistDisplayRefInterface',
-    ),
+    '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',
     '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/ArcanistLandEngine.php b/src/land/engine/ArcanistLandEngine.php
index 29365a9d..d02eec5a 100644
--- a/src/land/engine/ArcanistLandEngine.php
+++ b/src/land/engine/ArcanistLandEngine.php
@@ -1,1581 +1,1574 @@
 <?php
 
 abstract class ArcanistLandEngine
   extends ArcanistWorkflowEngine {
 
   private $sourceRefs;
   private $shouldHold;
   private $shouldKeep;
   private $shouldPreview;
   private $isIncremental;
   private $ontoRemoteArgument;
   private $ontoArguments;
   private $intoEmptyArgument;
   private $intoLocalArgument;
   private $intoRemoteArgument;
   private $intoArgument;
   private $strategyArgument;
   private $strategy;
 
   private $revisionSymbol;
   private $revisionSymbolRef;
 
   private $ontoRemote;
   private $ontoRefs;
   private $intoRemote;
   private $intoRef;
   private $intoEmpty;
   private $intoLocal;
 
   private $localState;
   private $hasUnpushedChanges;
   private $pickArgument;
 
   final public function setOntoRemote($onto_remote) {
     $this->ontoRemote = $onto_remote;
     return $this;
   }
 
   final public function getOntoRemote() {
     return $this->ontoRemote;
   }
 
   final public function setOntoRefs($onto_refs) {
     $this->ontoRefs = $onto_refs;
     return $this;
   }
 
   final public function getOntoRefs() {
     return $this->ontoRefs;
   }
 
   final public function setIntoRemote($into_remote) {
     $this->intoRemote = $into_remote;
     return $this;
   }
 
   final public function getIntoRemote() {
     return $this->intoRemote;
   }
 
   final public function setIntoRef($into_ref) {
     $this->intoRef = $into_ref;
     return $this;
   }
 
   final public function getIntoRef() {
     return $this->intoRef;
   }
 
   final public function setIntoEmpty($into_empty) {
     $this->intoEmpty = $into_empty;
     return $this;
   }
 
   final public function getIntoEmpty() {
     return $this->intoEmpty;
   }
 
   final public function setPickArgument($pick_argument) {
     $this->pickArgument = $pick_argument;
     return $this;
   }
 
   final public function getPickArgument() {
     return $this->pickArgument;
   }
 
   final public function setIntoLocal($into_local) {
     $this->intoLocal = $into_local;
     return $this;
   }
 
   final public function getIntoLocal() {
     return $this->intoLocal;
   }
 
   final public function setShouldHold($should_hold) {
     $this->shouldHold = $should_hold;
     return $this;
   }
 
   final public function getShouldHold() {
     return $this->shouldHold;
   }
 
   final public function setShouldKeep($should_keep) {
     $this->shouldKeep = $should_keep;
     return $this;
   }
 
   final public function getShouldKeep() {
     return $this->shouldKeep;
   }
 
   final public function setStrategyArgument($strategy_argument) {
     $this->strategyArgument = $strategy_argument;
     return $this;
   }
 
   final public function getStrategyArgument() {
     return $this->strategyArgument;
   }
 
   final public function setStrategy($strategy) {
     $this->strategy = $strategy;
     return $this;
   }
 
   final public function getStrategy() {
     return $this->strategy;
   }
 
   final public function setRevisionSymbol($revision_symbol) {
     $this->revisionSymbol = $revision_symbol;
     return $this;
   }
 
   final public function getRevisionSymbol() {
     return $this->revisionSymbol;
   }
 
   final public function setRevisionSymbolRef(
     ArcanistRevisionSymbolRef $revision_ref) {
     $this->revisionSymbolRef = $revision_ref;
     return $this;
   }
 
   final public function getRevisionSymbolRef() {
     return $this->revisionSymbolRef;
   }
 
   final public function setShouldPreview($should_preview) {
     $this->shouldPreview = $should_preview;
     return $this;
   }
 
   final public function getShouldPreview() {
     return $this->shouldPreview;
   }
 
   final public function setSourceRefs(array $source_refs) {
     $this->sourceRefs = $source_refs;
     return $this;
   }
 
   final public function getSourceRefs() {
     return $this->sourceRefs;
   }
 
   final public function setOntoRemoteArgument($remote_argument) {
     $this->ontoRemoteArgument = $remote_argument;
     return $this;
   }
 
   final public function getOntoRemoteArgument() {
     return $this->ontoRemoteArgument;
   }
 
   final public function setOntoArguments(array $onto_arguments) {
     $this->ontoArguments = $onto_arguments;
     return $this;
   }
 
   final public function getOntoArguments() {
     return $this->ontoArguments;
   }
 
   final public function setIsIncremental($is_incremental) {
     $this->isIncremental = $is_incremental;
     return $this;
   }
 
   final public function getIsIncremental() {
     return $this->isIncremental;
   }
 
   final public function setIntoEmptyArgument($into_empty_argument) {
     $this->intoEmptyArgument = $into_empty_argument;
     return $this;
   }
 
   final public function getIntoEmptyArgument() {
     return $this->intoEmptyArgument;
   }
 
   final public function setIntoLocalArgument($into_local_argument) {
     $this->intoLocalArgument = $into_local_argument;
     return $this;
   }
 
   final public function getIntoLocalArgument() {
     return $this->intoLocalArgument;
   }
 
   final public function setIntoRemoteArgument($into_remote_argument) {
     $this->intoRemoteArgument = $into_remote_argument;
     return $this;
   }
 
   final public function getIntoRemoteArgument() {
     return $this->intoRemoteArgument;
   }
 
   final public function setIntoArgument($into_argument) {
     $this->intoArgument = $into_argument;
     return $this;
   }
 
   final public function getIntoArgument() {
     return $this->intoArgument;
   }
 
   private function setLocalState(ArcanistRepositoryLocalState $local_state) {
     $this->localState = $local_state;
     return $this;
   }
 
   final protected function getLocalState() {
     return $this->localState;
   }
 
   private function setHasUnpushedChanges($unpushed) {
     $this->hasUnpushedChanges = $unpushed;
     return $this;
   }
 
   final protected function getHasUnpushedChanges() {
     return $this->hasUnpushedChanges;
   }
 
   final protected function getOntoConfigurationKey() {
     return 'arc.land.onto';
   }
 
   final protected function getOntoFromConfiguration() {
     $config_key = $this->getOntoConfigurationKey();
     return $this->getWorkflow()->getConfig($config_key);
   }
 
   final protected function getOntoRemoteConfigurationKey() {
     return 'arc.land.onto-remote';
   }
 
   final protected function getOntoRemoteFromConfiguration() {
     $config_key = $this->getOntoRemoteConfigurationKey();
     return $this->getWorkflow()->getConfig($config_key);
   }
 
   final protected function getStrategyConfigurationKey() {
     return 'arc.land.strategy';
   }
 
   final protected function getStrategyFromConfiguration() {
     $config_key = $this->getStrategyConfigurationKey();
     return $this->getWorkflow()->getConfig($config_key);
   }
 
   final protected function confirmRevisions(array $sets) {
     assert_instances_of($sets, 'ArcanistLandCommitSet');
 
     $revision_refs = mpull($sets, 'getRevisionRef');
     $viewer = $this->getViewer();
     $viewer_phid = $viewer->getPHID();
 
     $unauthored = array();
     foreach ($revision_refs as $revision_ref) {
       $author_phid = $revision_ref->getAuthorPHID();
       if ($author_phid !== $viewer_phid) {
         $unauthored[] = $revision_ref;
       }
     }
 
     if ($unauthored) {
       $this->getWorkflow()->loadHardpoints(
         $unauthored,
         array(
           ArcanistRevisionRef::HARDPOINT_AUTHORREF,
         ));
 
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('NOT REVISION AUTHOR'),
         pht(
           'You are landing revisions which you ("%s") are not the author of:',
           $viewer->getMonogram()));
 
       foreach ($unauthored as $revision_ref) {
-        $display_ref = $revision_ref->newDisplayRef();
+        $display_ref = $revision_ref->newRefView();
 
         $author_ref = $revision_ref->getAuthorRef();
         if ($author_ref) {
           $display_ref->appendLine(
             pht(
               'Author: %s',
               $author_ref->getMonogram()));
         }
 
         echo tsprintf('%s', $display_ref);
       }
 
       echo tsprintf(
         "\n%?\n",
         pht(
           'Use "Commandeer" in the web interface to become the author of '.
           'a revision.'));
 
       $query = pht('Land revisions you are not the author of?');
 
       $this->getWorkflow()
         ->getPrompt('arc.land.unauthored')
         ->setQuery($query)
         ->execute();
     }
 
     $planned = array();
     $published = array();
     $not_accepted = array();
     foreach ($revision_refs as $revision_ref) {
       if ($revision_ref->isStatusChangesPlanned()) {
         $planned[] = $revision_ref;
       } else if ($revision_ref->isStatusPublished()) {
         $published[] = $revision_ref;
       } else if (!$revision_ref->isStatusAccepted()) {
         $not_accepted[] = $revision_ref;
       }
     }
 
     // See T10233. Previously, this prompt was bundled with the generic "not
     // accepted" prompt, but users found it confusing and interpreted the
     // prompt as a bug.
 
     if ($planned) {
       $example_ref = head($planned);
 
       echo tsprintf(
         "\n%!\n%W\n\n%W\n\n%W\n\n",
         pht('%s REVISION(S) HAVE CHANGES PLANNED', phutil_count($planned)),
         pht(
           'You are landing %s revision(s) which are currently in the state '.
           '"%s", indicating that you expect to revise them before moving '.
           'forward.',
           phutil_count($planned),
           $example_ref->getStatusDisplayName()),
         pht(
           'Normally, you should update these %s revision(s), submit them '.
           'for review, and wait for reviewers to accept them before '.
           'you continue. To resubmit a revision for review, either: '.
           'update the revision with revised changes; or use '.
           '"Request Review" from the web interface.',
           phutil_count($planned)),
         pht(
           'These %s revision(s) have changes planned:',
           phutil_count($planned)));
 
       foreach ($planned as $revision_ref) {
-        echo tsprintf('%s', $revision_ref->newDisplayRef());
+        echo tsprintf('%s', $revision_ref->newRefView());
       }
 
       $query = pht(
         'Land %s revision(s) with changes planned?',
         phutil_count($planned));
 
       $this->getWorkflow()
         ->getPrompt('arc.land.changes-planned')
         ->setQuery($query)
         ->execute();
     }
 
     // See PHI1727. Previously, this prompt was bundled with the generic
     // "not accepted" prompt, but at least one user found it confusing.
 
     if ($published) {
       $example_ref = head($published);
 
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('%s REVISION(S) ARE ALREADY PUBLISHED', phutil_count($published)),
         pht(
           'You are landing %s revision(s) which are already in the state '.
           '"%s", indicating that they have previously landed:',
           phutil_count($published),
           $example_ref->getStatusDisplayName()));
 
       foreach ($published as $revision_ref) {
-        echo tsprintf('%s', $revision_ref->newDisplayRef());
+        echo tsprintf('%s', $revision_ref->newRefView());
       }
 
       $query = pht(
         'Land %s revision(s) that are already published?',
         phutil_count($published));
 
       $this->getWorkflow()
         ->getPrompt('arc.land.published')
         ->setQuery($query)
         ->execute();
     }
 
     if ($not_accepted) {
       $example_ref = head($not_accepted);
 
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('%s REVISION(S) ARE NOT ACCEPTED', phutil_count($not_accepted)),
         pht(
           'You are landing %s revision(s) which are not in state "Accepted", '.
           'indicating that they have not been accepted by reviewers. '.
           'Normally, you should land changes only once they have been '.
           'accepted. These revisions are in the wrong state:',
           phutil_count($not_accepted)));
 
       foreach ($not_accepted as $revision_ref) {
-        $display_ref = $revision_ref->newDisplayRef();
+        $display_ref = $revision_ref->newRefView();
         $display_ref->appendLine(
           pht(
             'Status: %s',
             $revision_ref->getStatusDisplayName()));
         echo tsprintf('%s', $display_ref);
       }
 
       $query = pht(
         'Land %s revision(s) in the wrong state?',
         phutil_count($not_accepted));
 
       $this->getWorkflow()
         ->getPrompt('arc.land.not-accepted')
         ->setQuery($query)
         ->execute();
     }
 
     $this->getWorkflow()->loadHardpoints(
       $revision_refs,
       array(
         ArcanistRevisionRef::HARDPOINT_PARENTREVISIONREFS,
       ));
 
     $open_parents = array();
     foreach ($revision_refs as $revision_phid => $revision_ref) {
       $parent_refs = $revision_ref->getParentRevisionRefs();
       foreach ($parent_refs as $parent_ref) {
         $parent_phid = $parent_ref->getPHID();
 
         // If we're landing a parent revision in this operation, we don't need
         // to complain that it hasn't been closed yet.
         if (isset($revision_refs[$parent_phid])) {
           continue;
         }
 
         if ($parent_ref->isClosed()) {
           continue;
         }
 
         if (!isset($open_parents[$parent_phid])) {
           $open_parents[$parent_phid] = array(
             'ref' => $parent_ref,
             'children' => array(),
           );
         }
 
         $open_parents[$parent_phid]['children'][] = $revision_ref;
       }
     }
 
     if ($open_parents) {
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('%s OPEN PARENT REVISION(S) ', phutil_count($open_parents)),
         pht(
           'The changes you are landing depend on %s open parent revision(s). '.
           'Usually, you should land parent revisions before landing the '.
           'changes which depend on them. These parent revisions are open:',
           phutil_count($open_parents)));
 
       foreach ($open_parents as $parent_phid => $spec) {
         $parent_ref = $spec['ref'];
 
-        $display_ref = $parent_ref->newDisplayRef();
+        $display_ref = $parent_ref->newRefView();
 
         $display_ref->appendLine(
           pht(
             'Status: %s',
             $parent_ref->getStatusDisplayName()));
 
         foreach ($spec['children'] as $child_ref) {
           $display_ref->appendLine(
             pht(
               'Parent of: %s %s',
               $child_ref->getMonogram(),
               $child_ref->getName()));
         }
 
         echo tsprintf('%s', $display_ref);
       }
 
       $query = pht(
         'Land changes that depend on %s open revision(s)?',
         phutil_count($open_parents));
 
       $this->getWorkflow()
         ->getPrompt('arc.land.open-parents')
         ->setQuery($query)
         ->execute();
     }
 
     $this->confirmBuilds($revision_refs);
 
     // This is a reasonable place to bulk-load the commit messages, which
     // we'll need soon.
 
     $this->getWorkflow()->loadHardpoints(
       $revision_refs,
       array(
         ArcanistRevisionRef::HARDPOINT_COMMITMESSAGE,
       ));
   }
 
   private function confirmBuilds(array $revision_refs) {
     assert_instances_of($revision_refs, 'ArcanistRevisionRef');
 
     $this->getWorkflow()->loadHardpoints(
       $revision_refs,
       array(
         ArcanistRevisionRef::HARDPOINT_BUILDABLEREF,
       ));
 
     $buildable_refs = array();
     foreach ($revision_refs as $revision_ref) {
       $ref = $revision_ref->getBuildableRef();
       if ($ref) {
         $buildable_refs[] = $ref;
       }
     }
 
     $this->getWorkflow()->loadHardpoints(
       $buildable_refs,
       array(
         ArcanistBuildableRef::HARDPOINT_BUILDREFS,
       ));
 
     $build_refs = array();
     foreach ($buildable_refs as $buildable_ref) {
       foreach ($buildable_ref->getBuildRefs() as $build_ref) {
         $build_refs[] = $build_ref;
       }
     }
 
     $this->getWorkflow()->loadHardpoints(
       $build_refs,
       array(
         ArcanistBuildRef::HARDPOINT_BUILDPLANREF,
       ));
 
     $problem_builds = array();
     $has_failures = false;
     $has_ongoing = false;
 
     $build_refs = msortv($build_refs, 'getStatusSortVector');
     foreach ($build_refs as $build_ref) {
       $plan_ref = $build_ref->getBuildPlanRef();
       if (!$plan_ref) {
         continue;
       }
 
       $plan_behavior = $plan_ref->getBehavior('arc-land', 'always');
       $if_building = ($plan_behavior == 'building');
       $if_complete = ($plan_behavior == 'complete');
       $if_never = ($plan_behavior == 'never');
 
       // If the build plan "Never" warns when landing, skip it.
       if ($if_never) {
         continue;
       }
 
       // If the build plan warns when landing "If Complete" but the build is
       // not complete, skip it.
       if ($if_complete && !$build_ref->isComplete()) {
         continue;
       }
 
       // If the build plan warns when landing "If Building" but the build is
       // complete, skip it.
       if ($if_building && $build_ref->isComplete()) {
         continue;
       }
 
       // Ignore passing builds.
       if ($build_ref->isPassed()) {
         continue;
       }
 
       if ($build_ref->isComplete()) {
         $has_failures = true;
       } else {
         $has_ongoing = true;
       }
 
       $problem_builds[] = $build_ref;
     }
 
     if (!$problem_builds) {
       return;
     }
 
     $build_map = array();
     $failure_map = array();
     $buildable_map = mpull($buildable_refs, null, 'getPHID');
     $revision_map = mpull($revision_refs, null, 'getDiffPHID');
     foreach ($problem_builds as $build_ref) {
       $buildable_phid = $build_ref->getBuildablePHID();
       $buildable_ref = $buildable_map[$buildable_phid];
 
       $object_phid = $buildable_ref->getObjectPHID();
       $revision_ref = $revision_map[$object_phid];
 
       $revision_phid = $revision_ref->getPHID();
 
       if (!isset($build_map[$revision_phid])) {
         $build_map[$revision_phid] = array(
           'revisionRef' => $revision_ref,
           'buildRefs' => array(),
         );
       }
 
       $build_map[$revision_phid]['buildRefs'][] = $build_ref;
     }
 
     $log = $this->getLogEngine();
 
     if ($has_failures) {
       if ($has_ongoing) {
         $message = pht(
           '%s revision(s) have build failures or ongoing builds:',
           phutil_count($build_map));
 
         $query = pht(
           'Land %s revision(s) anyway, despite ongoing and failed builds?',
           phutil_count($build_map));
 
       } else {
         $message = pht(
           '%s revision(s) have build failures:',
           phutil_count($build_map));
 
         $query = pht(
           'Land %s revision(s) anyway, despite failed builds?',
           phutil_count($build_map));
       }
 
       echo tsprintf(
         "%!\n%s\n",
         pht('BUILD FAILURES'),
         $message);
 
       $prompt_key = 'arc.land.failed-builds';
     } else if ($has_ongoing) {
       echo tsprintf(
         "%!\n%s\n",
         pht('ONGOING BUILDS'),
         pht(
           '%s revision(s) have ongoing builds:',
           phutil_count($build_map)));
 
       $query = pht(
         'Land %s revision(s) anyway, despite ongoing builds?',
         phutil_count($build_map));
 
       $prompt_key = 'arc.land.ongoing-builds';
     }
 
+    $workflow = $this->getWorkflow();
+
     echo tsprintf("\n");
     foreach ($build_map as $build_item) {
       $revision_ref = $build_item['revisionRef'];
+      $revision_view = $revision_ref->newRefView();
+
+      $buildable_ref = $revision_ref->getBuildableRef();
+      $buildable_view = $buildable_ref->newRefView();
+
+      $raw_uri = $buildable_ref->getURI();
+      $raw_uri = $workflow->getAbsoluteURI($raw_uri);
+      $buildable_view->setURI($raw_uri);
 
-      echo tsprintf('%s', $revision_ref->newDisplayRef());
+      $revision_view->addChild($buildable_view);
 
       foreach ($build_item['buildRefs'] as $build_ref) {
-        echo tsprintf('%s', $build_ref->newDisplayRef());
+        $build_view = $build_ref->newRefView();
+        $buildable_view->addChild($build_view);
       }
 
+      echo tsprintf('%s', $revision_view);
       echo tsprintf("\n");
     }
 
-    echo tsprintf(
-      "\n%s\n",
-      pht('You can review build details here:'));
-
-    // TODO: Only show buildables with problem builds.
-
-    $workflow = $this->getWorkflow();
-
-    foreach ($buildable_refs as $buildable) {
-      $display_ref = $buildable->newDisplayRef();
-
-      $raw_uri = $buildable->getURI();
-      $raw_uri = $workflow->getAbsoluteURI($raw_uri);
-
-      $display_ref->setURI($raw_uri);
-
-      echo tsprintf('%s', $display_ref);
-    }
-
     $this->getWorkflow()
       ->getPrompt($prompt_key)
       ->setQuery($query)
       ->execute();
   }
 
   final protected function confirmImplicitCommits(array $sets, array $symbols) {
     assert_instances_of($sets, 'ArcanistLandCommitSet');
     assert_instances_of($symbols, 'ArcanistLandSymbol');
 
     $implicit = array();
     foreach ($sets as $set) {
       if ($set->hasImplicitCommits()) {
         $implicit[] = $set;
       }
     }
 
     if (!$implicit) {
       return;
     }
 
     echo tsprintf(
       "\n%!\n%W\n",
       pht('IMPLICIT COMMITS'),
       pht(
         'Some commits reachable from the specified sources (%s) are not '.
         'associated with revisions, and may not have been reviewed. These '.
         'commits will be landed as though they belong to the nearest '.
         'ancestor revision:',
         $this->getDisplaySymbols($symbols)));
 
     foreach ($implicit as $set) {
       $this->printCommitSet($set);
     }
 
     $query = pht(
       'Continue with this mapping between commits and revisions?');
 
     $this->getWorkflow()
       ->getPrompt('arc.land.implicit')
       ->setQuery($query)
       ->execute();
   }
 
   final protected function getDisplaySymbols(array $symbols) {
     $display = array();
 
     foreach ($symbols as $symbol) {
       $display[] = sprintf('"%s"', addcslashes($symbol->getSymbol(), '\\"'));
     }
 
     return implode(', ', $display);
   }
 
   final protected function printCommitSet(ArcanistLandCommitSet $set) {
     $revision_ref = $set->getRevisionRef();
 
     echo tsprintf(
       "\n%s",
-      $revision_ref->newDisplayRef());
+      $revision_ref->newRefView());
 
     foreach ($set->getCommits() as $commit) {
       $is_implicit = $commit->getIsImplicitCommit();
 
       $display_hash = $this->getDisplayHash($commit->getHash());
       $display_summary = $commit->getDisplaySummary();
 
       if ($is_implicit) {
         echo tsprintf(
           "       <bg:yellow> %s </bg> %s\n",
           $display_hash,
           $display_summary);
       } else {
         echo tsprintf(
           "        %s  %s\n",
           $display_hash,
           $display_summary);
       }
     }
   }
 
   final protected function loadRevisionRefs(array $commit_map) {
     assert_instances_of($commit_map, 'ArcanistLandCommit');
     $workflow = $this->getWorkflow();
 
     $state_refs = array();
     foreach ($commit_map as $commit) {
       $hash = $commit->getHash();
 
       $commit_ref = id(new ArcanistCommitRef())
         ->setCommitHash($hash);
 
       $state_ref = id(new ArcanistWorkingCopyStateRef())
         ->setCommitRef($commit_ref);
 
       $state_refs[$hash] = $state_ref;
     }
 
     $force_symbol_ref = $this->getRevisionSymbolRef();
     $force_ref = null;
     if ($force_symbol_ref) {
       $workflow->loadHardpoints(
         $force_symbol_ref,
         ArcanistSymbolRef::HARDPOINT_OBJECT);
 
       $force_ref = $force_symbol_ref->getObject();
       if (!$force_ref) {
         throw new PhutilArgumentUsageException(
           pht(
             'Symbol "%s" does not identify a valid revision.',
             $force_symbol_ref->getSymbol()));
       }
     }
 
     $workflow->loadHardpoints(
       $state_refs,
       ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS);
 
     foreach ($commit_map as $commit) {
       $hash = $commit->getHash();
       $state_ref = $state_refs[$hash];
       $revision_refs = $state_ref->getRevisionRefs();
       $commit->setRelatedRevisionRefs($revision_refs);
     }
 
     // For commits which have exactly one related revision, select it now.
 
     foreach ($commit_map as $commit) {
       $revision_refs = $commit->getRelatedRevisionRefs();
 
       if (count($revision_refs) !== 1) {
         continue;
       }
 
       $revision_ref = head($revision_refs);
       $commit->setExplicitRevisionRef($revision_ref);
     }
 
     // If we have a "--revision", select that revision for any commits with
     // no known related revisions.
 
     // Also select that revision for any commits which have several possible
     // revisions including that revision. This is relatively safe and
     // reasonable and doesn't require a warning.
 
     if ($force_ref) {
       $force_phid = $force_ref->getPHID();
       foreach ($commit_map as $commit) {
         if ($commit->getExplicitRevisionRef()) {
           continue;
         }
 
         $revision_refs = $commit->getRelatedRevisionRefs();
 
         if ($revision_refs) {
           $revision_refs = mpull($revision_refs, null, 'getPHID');
           if (!isset($revision_refs[$force_phid])) {
             continue;
           }
         }
 
         $commit->setExplicitRevisionRef($force_ref);
       }
     }
 
     // If we have a "--revision", identify any commits which it is not yet
     // selected for. These are commits which are not associated with the
     // identified revision but are associated with one or more other revisions.
 
     if ($force_ref) {
       $force_phid = $force_ref->getPHID();
 
       $confirm_force = array();
       foreach ($commit_map as $key => $commit) {
         $revision_ref = $commit->getExplicitRevisionRef();
 
         if (!$revision_ref) {
           continue;
         }
 
         if ($revision_ref->getPHID() === $force_phid) {
           continue;
         }
 
         $confirm_force[] = $commit;
       }
 
       if ($confirm_force) {
 
         // TODO: Make this more clear.
         // TODO: Show all the commits.
 
         throw new PhutilArgumentUsageException(
           pht(
             'TODO: You are forcing a revision, but commits are associated '.
             'with some other revision. Are you REALLY sure you want to land '.
             'ALL these commits with a different unrelated revision???'));
       }
 
       foreach ($confirm_force as $commit) {
         $commit->setExplicitRevisionRef($force_ref);
       }
     }
 
     // Finally, raise an error if we're left with ambiguous revisions. This
     // happens when we have no "--revision" and some commits in the range
     // that are associated with more than one revision.
 
     $ambiguous = array();
     foreach ($commit_map as $commit) {
       if ($commit->getExplicitRevisionRef()) {
         continue;
       }
 
       if (!$commit->getRelatedRevisionRefs()) {
         continue;
       }
 
       $ambiguous[] = $commit;
     }
 
     if ($ambiguous) {
       foreach ($ambiguous as $commit) {
         $symbols = $commit->getIndirectSymbols();
         $raw_symbols = mpull($symbols, 'getSymbol');
         $symbol_list = implode(', ', $raw_symbols);
         $display_hash = $this->getDisplayHash($hash);
 
         $revision_refs = $commit->getRelatedRevisionRefs();
 
         // TODO: Include "use 'arc look --type commit abc' to figure out why"
         // once that works?
 
         // TODO: We could print all the ambiguous commits.
 
         // TODO: Suggest "--pick" as a remedy once it exists?
 
         echo tsprintf(
           "\n%!\n%W\n\n",
           pht('AMBIGUOUS REVISION'),
           pht(
             'The revision associated with commit "%s" (an ancestor of: %s) '.
             'is ambiguous. These %s revision(s) are associated with the '.
             'commit:',
             $display_hash,
             implode(', ', $raw_symbols),
             phutil_count($revision_refs)));
 
         foreach ($revision_refs as $revision_ref) {
           echo tsprintf(
             '%s',
-            $revision_ref->newDisplayRef());
+            $revision_ref->newRefView());
         }
 
         echo tsprintf("\n");
 
         throw new PhutilArgumentUsageException(
           pht(
             'Revision for commit "%s" is ambiguous. Use "--revision" to force '.
             'selection of a particular revision.',
             $display_hash));
       }
     }
 
     // NOTE: We may exit this method with commits that are still unassociated.
     // These will be handled later by the "implicit commits" mechanism.
   }
 
   final protected function getDisplayHash($hash) {
     // TODO: This should be on the API object.
     return substr($hash, 0, 12);
   }
 
   final protected function confirmCommits(
     $into_commit,
     array $symbols,
     array $commit_map) {
 
     $commit_count = count($commit_map);
 
     if (!$commit_count) {
       $message = pht(
         'There are no commits reachable from the specified sources (%s) '.
         'which are not already present in the state you are merging '.
         'into ("%s"), so nothing can land.',
         $this->getDisplaySymbols($symbols),
         $this->getDisplayHash($into_commit));
 
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('NOTHING TO LAND'),
         $message);
 
       throw new PhutilArgumentUsageException(
         pht('There are no commits to land.'));
     }
 
     // Reverse the commit list so that it's oldest-first, since this is the
     // order we'll use to show revisions.
     $commit_map = array_reverse($commit_map, true);
 
     $warn_limit = $this->getWorkflow()->getLargeWorkingSetLimit();
     $show_limit = 5;
     if ($commit_count > $warn_limit) {
       if ($into_commit === null) {
         $message = pht(
           'There are %s commit(s) reachable from the specified sources (%s). '.
           'You are landing into the empty state, so all of these commits '.
           'will land:',
           new PhutilNumber($commit_count),
           $this->getDisplaySymbols($symbols));
       } else {
         $message = pht(
           'There are %s commit(s) reachable from the specified sources (%s) '.
           'that are not present in the repository state you are merging '.
           'into ("%s"). All of these commits will land:',
           new PhutilNumber($commit_count),
           $this->getDisplaySymbols($symbols),
           $this->getDisplayHash($into_commit));
       }
 
       echo tsprintf(
         "\n%!\n%W\n",
         pht('LARGE WORKING SET'),
         $message);
 
       $display_commits = array_merge(
         array_slice($commit_map, 0, $show_limit),
         array(null),
         array_slice($commit_map, -$show_limit));
 
       echo tsprintf("\n");
 
       foreach ($display_commits as $commit) {
         if ($commit === null) {
           echo tsprintf(
             "  %s\n",
             pht(
               '< ... %s more commits ... >',
               new PhutilNumber($commit_count - ($show_limit * 2))));
         } else {
           echo tsprintf(
             "  %s %s\n",
             $this->getDisplayHash($commit->getHash()),
             $commit->getDisplaySummary());
         }
       }
 
       $query = pht(
         'Land %s commit(s)?',
         new PhutilNumber($commit_count));
 
       $this->getWorkflow()
         ->getPrompt('arc.land.large-working-set')
         ->setQuery($query)
         ->execute();
     }
 
     // Build the commit objects into a tree.
     foreach ($commit_map as $commit_hash => $commit) {
       $parent_map = array();
       foreach ($commit->getParents() as $parent) {
         if (isset($commit_map[$parent])) {
           $parent_map[$parent] = $commit_map[$parent];
         }
       }
       $commit->setParentCommits($parent_map);
     }
 
     // Identify the commits which are heads (have no children).
     $child_map = array();
     foreach ($commit_map as $commit_hash => $commit) {
       foreach ($commit->getParents() as $parent) {
         $child_map[$parent][$commit_hash] = $commit;
       }
     }
 
     foreach ($commit_map as $commit_hash => $commit) {
       if (isset($child_map[$commit_hash])) {
         continue;
       }
       $commit->setIsHeadCommit(true);
     }
 
     return $commit_map;
   }
 
   public function execute() {
     $api = $this->getRepositoryAPI();
     $log = $this->getLogEngine();
 
     $this->validateArguments();
 
     $raw_symbols = $this->getSourceRefs();
     if (!$raw_symbols) {
       $raw_symbols = $this->getDefaultSymbols();
     }
 
     $symbols = array();
     foreach ($raw_symbols as $raw_symbol) {
       $symbols[] = id(new ArcanistLandSymbol())
         ->setSymbol($raw_symbol);
     }
 
     $this->resolveSymbols($symbols);
 
     $onto_remote = $this->selectOntoRemote($symbols);
     $this->setOntoRemote($onto_remote);
 
     $onto_refs = $this->selectOntoRefs($symbols);
     $this->confirmOntoRefs($onto_refs);
     $this->setOntoRefs($onto_refs);
 
     $this->selectIntoRemote();
     $this->selectIntoRef();
 
     $into_commit = $this->selectIntoCommit();
     $commit_map = $this->selectCommits($into_commit, $symbols);
 
     $this->loadRevisionRefs($commit_map);
 
     // TODO: It's possible we have a list of commits which includes disjoint
     // groups of commits associated with the same revision, or groups of
     // commits which do not form a range. We should test that here, since we
     // can't land commit groups which are not a single contiguous range.
 
     $revision_groups = array();
     foreach ($commit_map as $commit_hash => $commit) {
       $revision_ref = $commit->getRevisionRef();
 
       if (!$revision_ref) {
         echo tsprintf(
           "\n%!\n%W\n\n",
           pht('UNKNOWN REVISION'),
           pht(
             'Unable to determine which revision is associated with commit '.
             '"%s". Use "arc diff" to create or update a revision with this '.
             'commit, or "--revision" to force selection of a particular '.
             'revision.',
             $this->getDisplayHash($commit_hash)));
 
         throw new PhutilArgumentUsageException(
           pht(
             'Unable to determine revision for commit "%s".',
             $this->getDisplayHash($commit_hash)));
       }
 
       $revision_groups[$revision_ref->getPHID()][] = $commit;
     }
 
     $commit_heads = array();
     foreach ($commit_map as $commit) {
       if ($commit->getIsHeadCommit()) {
         $commit_heads[] = $commit;
       }
     }
 
     $revision_order = array();
     foreach ($commit_heads as $head) {
       foreach ($head->getAncestorRevisionPHIDs() as $phid) {
         $revision_order[$phid] = true;
       }
     }
 
     $revision_groups = array_select_keys(
       $revision_groups,
       array_keys($revision_order));
 
     $sets = array();
     foreach ($revision_groups as $revision_phid => $group) {
       $revision_ref = head($group)->getRevisionRef();
 
       $set = id(new ArcanistLandCommitSet())
         ->setRevisionRef($revision_ref)
         ->setCommits($group);
 
       $sets[$revision_phid] = $set;
     }
 
     $sets = $this->filterCommitSets($sets);
 
     if (!$this->getShouldPreview()) {
       $this->confirmImplicitCommits($sets, $symbols);
     }
 
     $log->writeStatus(
       pht('LANDING'),
       pht('These changes will land:'));
 
     foreach ($sets as $set) {
       $this->printCommitSet($set);
     }
 
     if ($this->getShouldPreview()) {
       $log->writeStatus(
         pht('PREVIEW'),
         pht('Completed preview of land operation.'));
       return;
     }
 
     $query = pht('Land these changes?');
     $this->getWorkflow()
       ->getPrompt('arc.land.confirm')
       ->setQuery($query)
       ->execute();
 
     $this->confirmRevisions($sets);
 
     $workflow = $this->getWorkflow();
 
     $is_incremental = $this->getIsIncremental();
     $is_hold = $this->getShouldHold();
     $is_keep = $this->getShouldKeep();
 
     $local_state = $api->newLocalState()
       ->setWorkflow($workflow)
       ->saveLocalState();
 
     $this->setLocalState($local_state);
 
     $seen_into = array();
     try {
       $last_key = last_key($sets);
 
       $need_cascade = array();
       $need_prune = array();
 
       foreach ($sets as $set_key => $set) {
         // Add these first, so we don't add them multiple times if we need
         // to retry a push.
         $need_prune[] = $set;
         $need_cascade[] = $set;
 
         while (true) {
           $into_commit = $this->executeMerge($set, $into_commit);
           $this->setHasUnpushedChanges(true);
 
           if ($is_hold) {
             $should_push = false;
           } else if ($is_incremental) {
             $should_push = true;
           } else {
             $is_last = ($set_key === $last_key);
             $should_push = $is_last;
           }
 
           if ($should_push) {
             try {
               $this->pushChange($into_commit);
               $this->setHasUnpushedChanges(false);
             } catch (Exception $ex) {
 
               // TODO: If the push fails, fetch and retry if the remote ref
               // has moved ahead of us.
 
               if ($this->getIntoLocal()) {
                 $can_retry = false;
               } else if ($this->getIntoEmpty()) {
                 $can_retry = false;
               } else if ($this->getIntoRemote() !== $this->getOntoRemote()) {
                 $can_retry = false;
               } else {
                 $can_retry = false;
               }
 
               if ($can_retry) {
                 // New commit state here
                 $into_commit = '..';
                 continue;
               }
 
               throw $ex;
             }
 
             if ($need_cascade) {
 
               // NOTE: We cascade each set we've pushed, but we're going to
               // cascade them from most recent to least recent. This way,
               // branches which descend from more recent changes only cascade
               // once, directly in to the correct state.
 
               $need_cascade = array_reverse($need_cascade);
               foreach ($need_cascade as $cascade_set) {
                 $this->cascadeState($set, $into_commit);
               }
               $need_cascade = array();
             }
 
             if (!$is_keep) {
               $this->pruneBranches($need_prune);
               $need_prune = array();
             }
           }
 
           break;
         }
       }
 
       if ($is_hold) {
         $this->didHoldChanges($into_commit);
         $local_state->discardLocalState();
       } else {
         // TODO: Restore this.
         // $this->getWorkflow()->askForRepositoryUpdate();
 
         $this->reconcileLocalState($into_commit, $local_state);
 
         $log->writeSuccess(
           pht('DONE'),
           pht('Landed changes.'));
       }
     } catch (Exception $ex) {
       $local_state->restoreLocalState();
       throw $ex;
     } catch (Throwable $ex) {
       $local_state->restoreLocalState();
       throw $ex;
     }
   }
 
   protected function validateArguments() {
     $log = $this->getLogEngine();
 
     $into_local = $this->getIntoLocalArgument();
     $into_empty = $this->getIntoEmptyArgument();
     $into_remote = $this->getIntoRemoteArgument();
 
     $into_count = 0;
     if ($into_remote !== null) {
       $into_count++;
     }
 
     if ($into_local) {
       $into_count++;
     }
 
     if ($into_empty) {
       $into_count++;
     }
 
     if ($into_count > 1) {
       throw new PhutilArgumentUsageException(
         pht(
           'Arguments "--into-local", "--into-remote", and "--into-empty" '.
           'are mutually exclusive.'));
     }
 
     $into = $this->getIntoArgument();
     if ($into && $into_empty) {
       throw new PhutilArgumentUsageException(
         pht(
           'Arguments "--into" and "--into-empty" are mutually exclusive.'));
     }
 
     $strategy = $this->selectMergeStrategy();
     $this->setStrategy($strategy);
 
     $is_pick = $this->getPickArgument();
     if ($is_pick && !$this->isSquashStrategy()) {
       throw new PhutilArgumentUsageException(
         pht(
           'You can not "--pick" changes under the "merge" strategy.'));
     }
 
     // Build the symbol ref here (which validates the format of the symbol),
     // but don't load the object until later on when we're sure we actually
     // need it, since loading it requires a relatively expensive Conduit call.
     $revision_symbol = $this->getRevisionSymbol();
     if ($revision_symbol) {
       $symbol_ref = id(new ArcanistRevisionSymbolRef())
         ->setSymbol($revision_symbol);
       $this->setRevisionSymbolRef($symbol_ref);
     }
 
     // NOTE: When a user provides: "--hold" or "--preview"; and "--incremental"
     // or various combinations of remote flags, the flags affecting push/remote
     // behavior have no effect.
 
     // These combinations are allowed to support adding "--preview" or "--hold"
     // to any command to run the same command with fewer side effects.
   }
 
   abstract protected function getDefaultSymbols();
   abstract protected function resolveSymbols(array $symbols);
   abstract protected function selectOntoRemote(array $symbols);
   abstract protected function selectOntoRefs(array $symbols);
   abstract protected function confirmOntoRefs(array $onto_refs);
   abstract protected function selectIntoRemote();
   abstract protected function selectIntoRef();
   abstract protected function selectIntoCommit();
   abstract protected function selectCommits($into_commit, array $symbols);
   abstract protected function executeMerge(
     ArcanistLandCommitSet $set,
     $into_commit);
   abstract protected function pushChange($into_commit);
   abstract protected function cascadeState(
     ArcanistLandCommitSet $set,
     $into_commit);
 
   protected function isSquashStrategy() {
     return ($this->getStrategy() === 'squash');
   }
 
   abstract protected function pruneBranches(array $sets);
 
   abstract protected function reconcileLocalState(
     $into_commit,
     ArcanistRepositoryLocalState $state);
 
   abstract protected function didHoldChanges($into_commit);
 
   private function selectMergeStrategy() {
     $log = $this->getLogEngine();
 
     $supported_strategies = array(
       'merge',
       'squash',
     );
     $supported_strategies = array_fuse($supported_strategies);
     $strategy_list = implode(', ', $supported_strategies);
 
     $strategy = $this->getStrategyArgument();
     if ($strategy !== null) {
       if (!isset($supported_strategies[$strategy])) {
         throw new PhutilArgumentUsageException(
           pht(
             'Merge strategy "%s" specified with "--strategy" is unknown. '.
             'Supported merge strategies are: %s.',
             $strategy,
             $strategy_list));
       }
 
       $log->writeStatus(
         pht('STRATEGY'),
         pht(
           'Merging with "%s" strategy, selected with "--strategy".',
           $strategy));
 
       return $strategy;
     }
 
     $strategy = $this->getStrategyFromConfiguration();
     if ($strategy !== null) {
       if (!isset($supported_strategies[$strategy])) {
         throw new PhutilArgumentUsageException(
           pht(
             'Merge strategy "%s" specified in "%s" configuration is '.
             'unknown. Supported merge strategies are: %s.',
             $strategy,
             $strategy_list));
       }
 
       $log->writeStatus(
         pht('STRATEGY'),
         pht(
           'Merging with "%s" strategy, configured with "%s".',
           $strategy,
           $this->getStrategyConfigurationKey()));
 
       return $strategy;
     }
 
     $strategy = 'squash';
 
     $log->writeStatus(
       pht('STRATEGY'),
       pht(
         'Merging with "%s" strategy, the default strategy.',
         $strategy));
 
     return $strategy;
   }
 
   private function filterCommitSets(array $sets) {
     assert_instances_of($sets, 'ArcanistLandCommitSet');
     $log = $this->getLogEngine();
 
     // If some of the ancestor revisions are already closed, and the user did
     // not specifically indicate that we should land them, and we are using
     // a "squash" strategy, discard those sets.
 
     if ($this->isSquashStrategy()) {
       $discard = array();
       foreach ($sets as $key => $set) {
         $revision_ref = $set->getRevisionRef();
 
         if (!$revision_ref->isClosed()) {
           continue;
         }
 
         if ($set->hasDirectSymbols()) {
           continue;
         }
 
         $discard[] = $set;
         unset($sets[$key]);
       }
 
       if ($discard) {
         echo tsprintf(
           "\n%!\n%W\n",
           pht('DISCARDING ANCESTORS'),
           pht(
             'Some ancestor commits are associated with revisions that have '.
             'already been closed. These changes will be skipped:'));
 
         foreach ($discard as $set) {
           $this->printCommitSet($set);
         }
 
         echo tsprintf("\n");
       }
     }
 
     // TODO: Some of the revisions we've identified may be mapped to an
     // outdated set of commits. We should look in local branches for a better
     // set of commits, and try to confirm that the state we're about to land
     // is the current state in Differential.
 
     $is_pick = $this->getPickArgument();
     if ($is_pick) {
       foreach ($sets as $key => $set) {
         if ($set->hasDirectSymbols()) {
           $set->setIsPick(true);
           continue;
         }
 
         unset($sets[$key]);
       }
     }
 
     return $sets;
   }
 
   final protected function newPassthruCommand($pattern /* , ... */) {
     $workflow = $this->getWorkflow();
     $argv = func_get_args();
 
     $api = $this->getRepositoryAPI();
 
     $passthru = call_user_func_array(
       array($api, 'newPassthru'),
       $argv);
 
     $command = $workflow->newCommand($passthru)
       ->setResolveOnError(true);
 
     return $command;
   }
 
   final protected function newPassthru($pattern /* , ... */) {
     $argv = func_get_args();
 
     $command = call_user_func_array(
       array($this, 'newPassthruCommand'),
       $argv);
 
     return $command->execute();
   }
 
 }
diff --git a/src/land/engine/ArcanistMercurialLandEngine.php b/src/land/engine/ArcanistMercurialLandEngine.php
index eeba0122..25b49929 100644
--- a/src/land/engine/ArcanistMercurialLandEngine.php
+++ b/src/land/engine/ArcanistMercurialLandEngine.php
@@ -1,1083 +1,1083 @@
 <?php
 
 final class ArcanistMercurialLandEngine
   extends ArcanistLandEngine {
 
   private $ontoBranchMarker;
   private $ontoMarkers;
 
   protected function getDefaultSymbols() {
     $api = $this->getRepositoryAPI();
     $log = $this->getLogEngine();
 
     // TODO: In Mercurial, you normally can not create a branch and a bookmark
     // with the same name. However, you can fetch a branch or bookmark from
     // a remote that has the same name as a local branch or bookmark of the
     // other type, and end up with a local branch and bookmark with the same
     // name. We should detect this and treat it as an error.
 
     // TODO: In Mercurial, you can create local bookmarks named
     // "default@default" and similar which do not surive a round trip through
     // a remote. Possibly, we should disallow interacting with these bookmarks.
 
     $markers = $api->newMarkerRefQuery()
       ->withIsActive(true)
       ->execute();
 
     $bookmark = null;
     foreach ($markers as $marker) {
       if ($marker->isBookmark()) {
         $bookmark = $marker->getName();
         break;
       }
     }
 
     if ($bookmark !== null) {
       $log->writeStatus(
         pht('SOURCE'),
         pht(
           'Landing the active bookmark, "%s".',
           $bookmark));
 
       return array($bookmark);
     }
 
     $branch = null;
     foreach ($markers as $marker) {
       if ($marker->isBranch()) {
         $branch = $marker->getName();
         break;
       }
     }
 
     if ($branch !== null) {
       $log->writeStatus(
         pht('SOURCE'),
         pht(
           'Landing the active branch, "%s".',
           $branch));
 
       return array($branch);
     }
 
     $commit = $api->getCanonicalRevisionName('.');
     $commit = $this->getDisplayHash($commit);
 
     $log->writeStatus(
       pht('SOURCE'),
       pht(
         'Landing the active commit, "%s".',
         $this->getDisplayHash($commit)));
 
     return array($commit);
   }
 
   protected function resolveSymbols(array $symbols) {
     assert_instances_of($symbols, 'ArcanistLandSymbol');
     $api = $this->getRepositoryAPI();
 
     $marker_types = array(
       ArcanistMarkerRef::TYPE_BOOKMARK,
       ArcanistMarkerRef::TYPE_BRANCH,
     );
 
     $unresolved = $symbols;
     foreach ($marker_types as $marker_type) {
       $markers = $api->newMarkerRefQuery()
         ->withMarkerTypes(array($marker_type))
         ->execute();
 
       $markers = mgroup($markers, 'getName');
 
       foreach ($unresolved as $key => $symbol) {
         $raw_symbol = $symbol->getSymbol();
 
         $named_markers = idx($markers, $raw_symbol);
         if (!$named_markers) {
           continue;
         }
 
         if (count($named_markers) > 1) {
           echo tsprintf(
             "\n%!\n%W\n\n",
             pht('AMBIGUOUS SYMBOL'),
             pht(
               'Symbol "%s" is ambiguous: it matches multiple markers '.
               '(of type "%s"). Use an unambiguous identifier.',
               $raw_symbol,
               $marker_type));
 
           foreach ($named_markers as $named_marker) {
-            echo tsprintf('%s', $named_marker->newDisplayRef());
+            echo tsprintf('%s', $named_marker->newRefView());
           }
 
           echo tsprintf("\n");
 
           throw new PhutilArgumentUsageException(
             pht(
               'Symbol "%s" is ambiguous.',
               $symbol));
         }
 
         $marker = head($named_markers);
 
         $symbol->setCommit($marker->getCommitHash());
 
         unset($unresolved[$key]);
       }
     }
 
     foreach ($unresolved as $symbol) {
       $raw_symbol = $symbol->getSymbol();
 
       // TODO: This doesn't have accurate error behavior if the user provides
       // a revset like "x::y".
       try {
         $commit = $api->getCanonicalRevisionName($raw_symbol);
       } catch (CommandException $ex) {
         $commit = null;
       }
 
       if ($commit === null) {
         throw new PhutilArgumentUsageException(
           pht(
             'Symbol "%s" does not identify a bookmark, branch, or commit.',
             $raw_symbol));
       }
 
       $symbol->setCommit($commit);
     }
   }
 
   protected function selectOntoRemote(array $symbols) {
     assert_instances_of($symbols, 'ArcanistLandSymbol');
     $api = $this->getRepositoryAPI();
 
     $remote = $this->newOntoRemote($symbols);
 
     $remote_ref = $api->newRemoteRefQuery()
       ->withNames(array($remote))
       ->executeOne();
     if (!$remote_ref) {
       throw new PhutilArgumentUsageException(
         pht(
           'No remote "%s" exists in this repository.',
           $remote));
     }
 
     // TODO: Allow selection of a bare URI.
 
     return $remote;
   }
 
   private function newOntoRemote(array $symbols) {
     assert_instances_of($symbols, 'ArcanistLandSymbol');
     $api = $this->getRepositoryAPI();
     $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();
 
     $default_remote = 'default';
 
     $log->writeStatus(
       pht('ONTO REMOTE'),
       pht(
         'Landing onto remote "%s", the default remote under Mercurial.',
         $default_remote));
 
     return $default_remote;
   }
 
   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();
 
     $default_onto = 'default';
 
     $log->writeStatus(
       pht('ONTO TARGET'),
       pht(
         'Landing onto target "%s", the default target under Mercurial.',
         $default_onto));
 
     return array($default_onto);
   }
 
   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));
       }
     }
 
     $remote_ref = id(new ArcanistRemoteRef())
       ->setRemoteName($this->getOntoRemote());
 
     $markers = $api->newMarkerRefQuery()
       ->withRemotes(array($remote_ref))
       ->execute();
 
     $onto_markers = array();
     $new_markers = array();
     foreach ($onto_refs as $onto_ref) {
       $matches = array();
       foreach ($markers as $marker) {
         if ($marker->getName() === $onto_ref) {
           $matches[] = $marker;
         }
       }
 
       $match_count = count($matches);
       if ($match_count > 1) {
         throw new PhutilArgumentUsageException(
           pht(
             'TODO: Ambiguous ref.'));
       } else if (!$match_count) {
         $new_bookmark = id(new ArcanistMarkerRef())
           ->setMarkerType(ArcanistMarkerRef::TYPE_BOOKMARK)
           ->setName($onto_ref)
           ->attachRemoteRef($remote_ref);
 
         $onto_markers[] = $new_bookmark;
         $new_markers[] = $new_bookmark;
       } else {
         $onto_markers[] = head($matches);
       }
     }
 
     $branches = array();
     foreach ($onto_markers as $onto_marker) {
       if ($onto_marker->isBranch()) {
         $branches[] = $onto_marker;
       }
 
       $branch_count = count($branches);
       if ($branch_count > 1) {
         echo tsprintf(
           "\n%!\n%W\n\n%W\n\n%W\n\n",
           pht('MULTIPLE "ONTO" BRANCHES'),
           pht(
             'You have selected multiple branches to push changes onto. '.
             'Pushing to multiple branches is not supported by "arc land" '.
             'in Mercurial: Mercurial commits may only belong to one '.
             'branch, so this operation can not be executed atomically.'),
           pht(
             'You may land one branches and any number of bookmarks in a '.
             'single operation.'),
           pht('These branches were selected:'));
 
         foreach ($branches as $branch) {
-          echo tsprintf('%s', $branch->newDisplayRef());
+          echo tsprintf('%s', $branch->newRefView());
         }
 
         echo tsprintf("\n");
 
         throw new PhutilArgumentUsageException(
           pht(
             'Landing onto multiple branches at once is not supported in '.
             'Mercurial.'));
       } else if ($branch_count) {
         $this->ontoBranchMarker = head($branches);
       }
     }
 
     if ($new_markers) {
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('CREATE %s BOOKMARK(S)', phutil_count($new_markers)),
         pht(
           'These %s symbol(s) do not exist in the remote. They will be created '.
           'as new bookmarks:',
           phutil_count($new_markers)));
 
 
       foreach ($new_markers as $new_marker) {
-        echo tsprintf('%s', $new_marker->newDisplayRef());
+        echo tsprintf('%s', $new_marker->newRefView());
       }
 
       echo tsprintf("\n");
 
       $query = pht(
         'Create %s new remote bookmark(s)?',
         phutil_count($new_markers));
 
       $this->getWorkflow()
         ->getPrompt('arc.land.create')
         ->setQuery($query)
         ->execute();
     }
 
     $this->ontoMarkers = $onto_markers;
   }
 
   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) {
 
       $remote_ref = $api->newRemoteRefQuery()
         ->withNames(array($into))
         ->executeOne();
       if (!$remote_ref) {
         throw new PhutilArgumentUsageException(
           pht(
             'No remote "%s" exists in this repository.',
             $into));
       }
 
       // TODO: Allow a raw URI.
 
       $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() {
     $log = $this->getLogEngine();
 
     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.
       $api = $this->getRepositoryAPI();
       $local_ref = $this->getIntoRef();
 
       // TODO: This error handling could probably be cleaner, it will just
       // raise an exception without any context.
 
       $into_commit = $api->getCanonicalRevisionName($local_ref);
 
       $log->writeStatus(
         pht('INTO COMMIT'),
         pht(
           'Preparing merge into local target "%s", at commit "%s".',
           $local_ref,
           $this->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(),
           $this->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 fetchTarget(ArcanistLandTarget $target) {
     $api = $this->getRepositoryAPI();
     $log = $this->getLogEngine();
 
     $target_name = $target->getRef();
 
     $remote_ref = id(new ArcanistRemoteRef())
       ->setRemoteName($target->getRemote());
 
     $markers = $api->newMarkerRefQuery()
       ->withRemotes(array($remote_ref))
       ->withNames(array($target_name))
       ->execute();
 
     $bookmarks = array();
     $branches = array();
     foreach ($markers as $marker) {
       if ($marker->isBookmark()) {
         $bookmarks[] = $marker;
       } else {
         $branches[] = $marker;
       }
     }
 
     if (!$bookmarks && !$branches) {
       throw new PhutilArgumentUsageException(
         pht(
           'Remote "%s" has no bookmark or branch named "%s".',
           $target->getRemote(),
           $target->getRef()));
     }
 
     if ($bookmarks && $branches) {
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('AMBIGUOUS MARKER'),
         pht(
           'In remote "%s", the name "%s" identifies one or more branch '.
           'heads and one or more bookmarks. Close, rename, or delete all '.
           'but one of these markers, or pull the state you want to merge '.
           'into and use "--into-local --into <hash>" to disambiguate the '.
           'desired merge target.',
           $target->getRemote(),
           $target->getRef()));
 
       throw new PhutilArgumentUsageException(
         pht('Merge target is ambiguous.'));
     }
 
     if ($bookmarks) {
       if (count($bookmarks) > 1) {
         throw new Exception(
           pht(
             'Remote "%s" has multiple bookmarks with name "%s". This '.
             'is unexpected.',
             $target->getRemote(),
             $target->getRef()));
       }
       $bookmark = head($bookmarks);
 
       $target_marker = $bookmark;
     }
 
     if ($branches) {
       if (count($branches) > 1) {
         echo tsprintf(
           "\n%!\n%W\n\n",
           pht('MULTIPLE BRANCH HEADS'),
           pht(
             'Remote "%s" has multiple branch heads named "%s". Close all '.
             'but one, or pull the head you want and use "--into-local '.
             '--into <hash>" to specify an explicit merge target.',
             $target->getRemote(),
             $target->getRef()));
 
         throw new PhutilArgumentUsageException(
           pht(
             'Remote branch has multiple heads.'));
       }
 
       $branch = head($branches);
 
       $target_marker = $branch;
     }
 
     if ($target_marker->isBranch()) {
       $err = $this->newPassthru(
         'pull --branch %s -- %s',
         $target->getRef(),
         $target->getRemote());
     } else {
 
       // NOTE: This may have side effects:
       //
       //   - It can create a "bookmark@remote" bookmark if there is a local
       //     bookmark with the same name that is not an ancestor.
       //   - It can create an arbitrary number of other bookmarks.
       //
       // Since these seem to generally be intentional behaviors in Mercurial,
       // and should theoretically be familiar to Mercurial users, just accept
       // them as the cost of doing business.
 
       $err = $this->newPassthru(
         'pull --bookmark %s -- %s',
         $target->getRef(),
         $target->getRemote());
     }
 
     // NOTE: It's possible that between the time we ran "ls-markers" and the
     // time we ran "pull" that the remote changed.
 
     // It may even have been rewound or rewritten, in which case we did not
     // actually fetch the ref we are about to return as a target. For now,
     // assume this didn't happen: it's so unlikely that it's probably not
     // worth spending 100ms to check.
 
     // TODO: If the Mercurial command server is revived, this check becomes
     // more reasonable if it's cheap.
 
     return $target_marker->getCommitHash();
   }
 
   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();
       $template = '{node}-{parents}-';
 
       if ($into_commit === null) {
         list($commits) = $api->execxLocal(
           'log --rev %s --template %s --',
           hgsprintf('reverse(ancestors(%s))', $into_commit),
           $template);
       } else {
         list($commits) = $api->execxLocal(
           'log --rev %s --template %s --',
           hgsprintf(
             'reverse(ancestors(%s) - ancestors(%s))',
             $symbol_commit,
             $into_commit),
           $template);
       }
 
       $commits = phutil_split_lines($commits, false);
       $is_first = true;
       foreach ($commits as $line) {
         if (!strlen($line)) {
           continue;
         }
 
         $parts = explode('-', $line, 3);
         if (count($parts) < 3) {
           throw new Exception(
             pht(
               'Unexpected output from "hg 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 executeMerge(ArcanistLandCommitSet $set, $into_commit) {
     $api = $this->getRepositoryAPI();
 
     if ($this->getStrategy() !== 'squash') {
       throw new Exception(pht('TODO: Support merge strategies'));
     }
 
     // TODO: Add a Mercurial version check requiring 2.1.1 or newer.
 
     $api->execxLocal(
       'update --rev %s',
       hgsprintf('%s', $into_commit));
 
     $commits = $set->getCommits();
 
     $min_commit = last($commits)->getHash();
     $max_commit = head($commits)->getHash();
 
     $revision_ref = $set->getRevisionRef();
     $commit_message = $revision_ref->getCommitMessage();
 
     // If we're landing "--onto" a branch, set that as the branch marker
     // before creating the new commit.
 
     // TODO: We could skip this if we know that the "$into_commit" already
     // has the right branch, which it will if we created it.
 
     $branch_marker = $this->ontoBranchMarker;
     if ($branch_marker) {
       $api->execxLocal('branch -- %s', $branch_marker->getName());
     }
 
     try {
       $argv = array();
       $argv[] = '--dest';
       $argv[] = hgsprintf('%s', $into_commit);
 
       $argv[] = '--rev';
       $argv[] = hgsprintf('%s..%s', $min_commit, $max_commit);
 
       $argv[] = '--logfile';
       $argv[] = '-';
 
       $argv[] = '--keep';
       $argv[] = '--collapse';
 
       $future = $api->execFutureLocal('rebase %Ls', $argv);
       $future->write($commit_message);
       $future->resolvex();
 
     } catch (CommandException $ex) {
       // TODO
       // $api->execManualLocal('rebase --abort');
       throw $ex;
     }
 
     list($stdout) = $api->execxLocal('log --rev tip --template %s', '{node}');
     $new_cursor = trim($stdout);
 
     return $new_cursor;
   }
 
   protected function pushChange($into_commit) {
     $api = $this->getRepositoryAPI();
 
     list($head, $body, $tail) = $this->newPushCommands($into_commit);
 
     foreach ($head as $command) {
       $api->execxLocal('%Ls', $command);
     }
 
     try {
       foreach ($body as $command) {
         $this->newPasthru('%Ls', $command);
       }
     } finally {
       foreach ($tail as $command) {
         $api->execxLocal('%Ls', $command);
       }
     }
   }
 
   private function newPushCommands($into_commit) {
     $api = $this->getRepositoryAPI();
 
     $head_commands = array();
     $body_commands = array();
     $tail_commands = array();
 
     $bookmarks = array();
     foreach ($this->ontoMarkers as $onto_marker) {
       if (!$onto_marker->isBookmark()) {
         continue;
       }
       $bookmarks[] = $onto_marker;
     }
 
     // If we're pushing to bookmarks, move all the bookmarks we want to push
     // to the merge commit. (There doesn't seem to be any way to specify
     // "push commit X as bookmark Y" in Mercurial.)
 
     $restore = array();
     if ($bookmarks) {
       $markers = $api->newMarkerRefQuery()
         ->withNames(mpull($bookmarks, 'getName'))
         ->withMarkerTypes(array(ArcanistMarkerRef::TYPE_BOOKMARK))
         ->execute();
       $markers = mpull($markers, 'getCommitHash', 'getName');
 
       foreach ($bookmarks as $bookmark) {
         $bookmark_name = $bookmark->getName();
 
         $old_position = idx($markers, $bookmark_name);
         $new_position = $into_commit;
 
         if ($old_position === $new_position) {
           continue;
         }
 
         $head_commands[] = array(
           'bookmark',
           '--force',
           '--rev',
           hgsprintf('%s', $this->getDisplayHash($new_position)),
           '--',
           $bookmark_name,
         );
 
         $api->execxLocal(
           'bookmark --force --rev %s -- %s',
           hgsprintf('%s', $new_position),
           $bookmark_name);
 
         $restore[$bookmark_name] = $old_position;
       }
     }
 
     // Now, prepare the actual push.
 
     $argv = array();
     $argv[] = 'push';
 
     if ($bookmarks) {
       // If we're pushing at least one bookmark, we can just specify the list
       // of bookmarks as things we want to push.
       foreach ($bookmarks as $bookmark) {
         $argv[] = '--bookmark';
         $argv[] = $bookmark->getName();
       }
     } else {
       // Otherwise, specify the commit itself.
       $argv[] = '--rev';
       $argv[] = hgsprintf('%s', $into_commit);
     }
 
     $argv[] = '--';
     $argv[] = $this->getOntoRemote();
 
     $body_commands[] = $argv;
 
     // Finally, restore the bookmarks.
 
     foreach ($restore as $bookmark_name => $old_position) {
       $tail = array();
       $tail[] = 'bookmark';
 
       if ($old_position === null) {
         $tail[] = '--delete';
       } else {
         $tail[] = '--force';
         $tail[] = '--rev';
         $tail[] = hgsprintf('%s', $this->getDisplayHash($old_position));
       }
 
       $tail[] = '--';
       $tail[] = $bookmark_name;
 
       $tail_commands[] = $tail;
     }
 
     return array(
       $head_commands,
       $body_commands,
       $tail_commands,
     );
   }
 
   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;
     }
 
     $old_commit = last($set->getCommits())->getHash();
     $new_commit = $into_commit;
 
     list($output) = $api->execxLocal(
       'log --rev %s --template %s',
       hgsprintf('children(%s)', $old_commit),
       '{node}\n');
     $child_hashes = phutil_split_lines($output, false);
 
     foreach ($child_hashes as $child_hash) {
       if (!strlen($child_hash)) {
         continue;
       }
 
       // TODO: If the only heads which are descendants of this child will
       // be deleted, we can skip this rebase?
 
       try {
         $api->execxLocal(
           'rebase --source %s --dest %s --keep --keepbranches',
           $child_hash,
           $new_commit);
       } catch (CommandException $ex) {
         // TODO: Recover state.
         throw $ex;
       }
     }
   }
 
 
   protected function pruneBranches(array $sets) {
     assert_instances_of($sets, 'ArcanistLandCommitSet');
     $api = $this->getRepositoryAPI();
     $log = $this->getLogEngine();
 
     // This has no effect when we're executing a merge strategy.
     if (!$this->isSquashStrategy()) {
       return;
     }
 
     $revs = array();
 
     // We've rebased all descendants already, so we can safely delete all
     // of these commits.
 
     $sets = array_reverse($sets);
     foreach ($sets as $set) {
       $commits = $set->getCommits();
 
       $min_commit = head($commits)->getHash();
       $max_commit = last($commits)->getHash();
 
       $revs[] = hgsprintf('%s::%s', $min_commit, $max_commit);
     }
 
     $rev_set = '('.implode(') or (', $revs).')';
 
     // See PHI45. If we have "hg evolve", get rid of old commits using
     // "hg prune" instead of "hg strip".
 
     // If we "hg strip" a commit which has an obsolete predecessor, it
     // removes the obsolescence marker and revives the predecessor. This is
     // not desirable: we want to destroy all predecessors of these commits.
 
     if ($api->getMercurialFeature('evolve')) {
       $api->execxLocal(
         'prune --rev %s',
         $rev_set);
     } else {
       $api->execxLocal(
         '--config extensions.strip= strip --rev %s',
         $rev_set);
     }
   }
 
   protected function reconcileLocalState(
     $into_commit,
     ArcanistRepositoryLocalState $state) {
 
     // TODO: For now, just leave users wherever they ended up.
 
     $state->discardLocalState();
   }
 
   protected function didHoldChanges($into_commit) {
     $log = $this->getLogEngine();
     $local_state = $this->getLocalState();
 
     $message = pht(
       'Holding changes locally, they have not been pushed.');
 
     list($head, $body, $tail) = $this->newPushCommands($into_commit);
     $commands = array_merge($head, $body, $tail);
 
     echo tsprintf(
       "\n%!\n%s\n\n",
       pht('HOLD CHANGES'),
       $message);
 
     echo tsprintf(
       "%s\n\n",
       pht('To push changes manually, run these %s command(s):',
         phutil_count($commands)));
 
     foreach ($commands as $command) {
       echo tsprintf('%>', csprintf('hg %Ls', $command));
     }
 
     echo tsprintf("\n");
 
     $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 and bookmarks have not been changed, and are still '.
         'in the same state as before.'));
   }
 
 }
diff --git a/src/ref/ArcanistDisplayRefInterface.php b/src/ref/ArcanistDisplayRefInterface.php
deleted file mode 100644
index 550763ec..00000000
--- a/src/ref/ArcanistDisplayRefInterface.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-interface ArcanistDisplayRefInterface {
-
-  public function getDisplayRefObjectName();
-  public function getDisplayRefTitle();
-
-}
diff --git a/src/ref/ArcanistRef.php b/src/ref/ArcanistRef.php
index 8934a08f..1f153af8 100644
--- a/src/ref/ArcanistRef.php
+++ b/src/ref/ArcanistRef.php
@@ -1,12 +1,21 @@
 <?php
 
 abstract class ArcanistRef
   extends ArcanistHardpointObject {
 
   abstract public function getRefDisplayName();
 
-  final public function newDisplayRef() {
-    return id(new ArcanistDisplayRef())
+  final public function newRefView() {
+    $ref_view = id(new ArcanistRefView())
       ->setRef($this);
+
+    $this->buildRefView($ref_view);
+
+    return $ref_view;
   }
+
+  protected function buildRefView(ArcanistRefView $view) {
+    return null;
+  }
+
 }
diff --git a/src/ref/ArcanistDisplayRef.php b/src/ref/ArcanistRefView.php
similarity index 58%
rename from src/ref/ArcanistDisplayRef.php
rename to src/ref/ArcanistRefView.php
index 631b65b4..bb166aca 100644
--- a/src/ref/ArcanistDisplayRef.php
+++ b/src/ref/ArcanistRefView.php
@@ -1,99 +1,146 @@
 <?php
 
-final class ArcanistDisplayRef
+final class ArcanistRefView
   extends Phobject
   implements
     ArcanistTerminalStringInterface {
 
+  private $objectName;
+  private $title;
   private $ref;
   private $uri;
   private $lines = array();
+  private $children = array();
 
   public function setRef(ArcanistRef $ref) {
     $this->ref = $ref;
     return $this;
   }
 
   public function getRef() {
     return $this->ref;
   }
 
+  public function setObjectName($object_name) {
+    $this->objectName = $object_name;
+    return $this;
+  }
+
+  public function getObjectName() {
+    return $this->objectName;
+  }
+
+  public function setTitle($title) {
+    $this->title = $title;
+    return $this;
+  }
+
+  public function getTitle() {
+    return $this->title;
+  }
+
   public function setURI($uri) {
     $this->uri = $uri;
     return $this;
   }
 
   public function getURI() {
     return $this->uri;
   }
 
+  public function addChild(ArcanistRefView $view) {
+    $this->children[] = $view;
+    return $this;
+  }
+
+  private function getChildren() {
+    return $this->children;
+  }
+
   public function appendLine($line) {
     $this->lines[] = $line;
     return $this;
   }
 
   public function newTerminalString() {
+    return $this->newLines(0);
+  }
+
+  private function newLines($indent) {
     $ref = $this->getRef();
 
-    if ($ref instanceof ArcanistDisplayRefInterface) {
-      $object_name = $ref->getDisplayRefObjectName();
-      $title = $ref->getDisplayRefTitle();
-    } else {
-      $object_name = null;
-      $title = $ref->getRefDisplayName();
-    }
+    $object_name = $this->getObjectName();
+    $title = $this->getTitle();
 
     if ($object_name !== null) {
       $reserve_width = phutil_utf8_console_strlen($object_name) + 1;
     } else {
       $reserve_width = 0;
     }
 
+    if ($indent) {
+      $indent_text = str_repeat('  ', $indent);
+    } else {
+      $indent_text = '';
+    }
+    $indent_width = strlen($indent_text);
+
     $marker_width = 6;
     $display_width = phutil_console_get_terminal_width();
 
     $usable_width = ($display_width - $marker_width - $reserve_width);
+    $usable_width = ($usable_width - $indent_width);
 
     // If the terminal is extremely narrow, don't degrade so much that the
     // output is completely unusable.
     $usable_width = max($usable_width, 16);
 
     // TODO: This should truncate based on console display width, not
     // glyphs, but there's currently no "setMaximumConsoleCharacterWidth()".
 
     $title = id(new PhutilUTF8StringTruncator())
       ->setMaximumGlyphs($usable_width)
       ->truncateString($title);
 
     if ($object_name !== null) {
       if (strlen($title)) {
         $display_text = tsprintf('**%s** %s', $object_name, $title);
       } else {
         $display_text = tsprintf('**%s**', $object_name);
       }
     } else {
       $display_text = $title;
     }
 
-    $ref = $this->getRef();
     $output = array();
 
     $output[] =  tsprintf(
-      "<bg:cyan>**  *  **</bg> %s\n",
+      "<bg:cyan>**  *  **</bg> %s%s\n",
+      $indent_text,
       $display_text);
 
     $uri = $this->getURI();
     if ($uri !== null) {
       $output[] = tsprintf(
-        "<bg:cyan>** :// **</bg>    __%s__\n",
+        "<bg:cyan>** :// **</bg>   %s__%s__\n",
+        $indent_text,
         $uri);
     }
 
     foreach ($this->lines as $line) {
-      $output[] = tsprintf("        %s\n", $line);
+      $output[] = tsprintf(
+        "        %s%s\n",
+        $indent_text,
+        $line);
+    }
+
+    foreach ($this->getChildren() as $child) {
+      foreach ($child->newLines($indent + 1) as $line) {
+        $output[] = $line;
+      }
     }
 
     return $output;
   }
 
 }
diff --git a/src/ref/build/ArcanistBuildRef.php b/src/ref/build/ArcanistBuildRef.php
index f2ffcd90..7b1fe227 100644
--- a/src/ref/build/ArcanistBuildRef.php
+++ b/src/ref/build/ArcanistBuildRef.php
@@ -1,106 +1,102 @@
 <?php
 
 final class ArcanistBuildRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   const HARDPOINT_BUILDPLANREF = 'ref.build.buildplanRef';
 
   private $parameters;
 
   protected function newHardpoints() {
     return array(
       $this->newHardpoint(self::HARDPOINT_BUILDPLANREF),
     );
   }
 
   public function getRefDisplayName() {
-    return $this->getDisplayRefObjectName();
+    return pht('Build %d', $this->getID());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getName() {
     return idxv($this->parameters, array('fields', 'name'));
   }
 
-  public function getDisplayRefObjectName() {
-    return pht('Build %d', $this->getID());
-  }
-
-  public function getDisplayRefTitle() {
-    return $this->getName();
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getRefDisplayName())
+      ->setTitle($this->getName());
   }
 
   public function getBuildPlanRef() {
     return $this->getHardpoint(self::HARDPOINT_BUILDPLANREF);
   }
 
   public function getBuildablePHID() {
     return idxv($this->parameters, array('fields', 'buildablePHID'));
   }
 
   public function getBuildPlanPHID() {
     return idxv($this->parameters, array('fields', 'buildPlanPHID'));
   }
 
   public function getStatus() {
     return idxv($this->parameters, array('fields', 'buildStatus', 'value'));
   }
 
   public function getStatusName() {
     return idxv($this->parameters, array('fields', 'buildStatus', 'name'));
   }
 
   public function getStatusANSIColor() {
     return idxv(
       $this->parameters,
       array('fields', 'buildStatus', 'color.ansi'));
   }
 
   public function isComplete() {
     switch ($this->getStatus()) {
       case 'passed':
       case 'failed':
       case 'aborted':
       case 'error':
       case 'deadlocked':
         return true;
       default:
         return false;
     }
   }
 
   public function isPassed() {
     return ($this->getStatus() === 'passed');
   }
 
   public function getStatusSortVector() {
     $status = $this->getStatus();
 
     // For now, just sort passed builds first.
     if ($this->isPassed()) {
       $status_class = 1;
     } else {
       $status_class = 2;
     }
 
     return id(new PhutilSortVector())
       ->addInt($status_class)
       ->addString($status);
   }
 
 }
diff --git a/src/ref/buildable/ArcanistBuildableRef.php b/src/ref/buildable/ArcanistBuildableRef.php
index bf19ebd1..b91df702 100644
--- a/src/ref/buildable/ArcanistBuildableRef.php
+++ b/src/ref/buildable/ArcanistBuildableRef.php
@@ -1,69 +1,65 @@
 <?php
 
 final class ArcanistBuildableRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   const HARDPOINT_BUILDREFS = 'ref.buildable.buildRefs';
 
   private $parameters;
 
   protected function newHardpoints() {
     $object_list = new ArcanistObjectListHardpoint();
     return array(
       $this->newTemplateHardpoint(
         self::HARDPOINT_BUILDREFS,
         $object_list),
     );
   }
 
   public function getRefDisplayName() {
     return pht('Buildable "%s"', $this->getMonogram());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getObjectPHID() {
     return idxv($this->parameters, array('fields', 'objectPHID'));
   }
 
   public function getMonogram() {
     return 'B'.$this->getID();
   }
 
-  public function getDisplayRefObjectName() {
-    return $this->getMonogram();
-  }
-
-  public function getDisplayRefTitle() {
-    return pht('Buildable %d', $this->getID());
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getMonogram())
+      ->setTitle($this->getRefDisplayName());
   }
 
   public function getBuildRefs() {
     return $this->getHardpoint(self::HARDPOINT_BUILDREFS);
   }
 
   public function getURI() {
     $uri = idxv($this->parameters, array('fields', 'uri'));
 
     if ($uri === null) {
       $uri = '/'.$this->getMonogram();
     }
 
     return $uri;
   }
 
 }
diff --git a/src/ref/buildplan/ArcanistBuildPlanRef.php b/src/ref/buildplan/ArcanistBuildPlanRef.php
index 37570513..ea0ad609 100644
--- a/src/ref/buildplan/ArcanistBuildPlanRef.php
+++ b/src/ref/buildplan/ArcanistBuildPlanRef.php
@@ -1,47 +1,43 @@
 <?php
 
 final class ArcanistBuildPlanRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   private $parameters;
 
   public function getRefDisplayName() {
-    return $this->getDisplayRefObjectName();
+    return pht('Build Plan %d', $this->getID());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getName() {
     return idxv($this->parameters, array('fields', 'name'));
   }
 
-  public function getDisplayRefObjectName() {
-    return pht('Build Plan %d', $this->getID());
-  }
-
-  public function getDisplayRefTitle() {
-    return $this->getName();
-  }
-
   public function getBehavior($behavior_key, $default = null) {
     return idxv(
       $this->parameters,
       array('fields', 'behaviors', $behavior_key, 'value'),
       $default);
   }
 
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getRefDisplayName())
+      ->setTitle($this->getName());
+  }
+
 }
diff --git a/src/ref/file/ArcanistFileRef.php b/src/ref/file/ArcanistFileRef.php
index 37fcf520..615987e9 100644
--- a/src/ref/file/ArcanistFileRef.php
+++ b/src/ref/file/ArcanistFileRef.php
@@ -1,62 +1,58 @@
 <?php
 
 final class ArcanistFileRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   private $parameters;
 
   public function getRefDisplayName() {
     return pht('File "%s"', $this->getMonogram());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getName() {
     return idxv($this->parameters, array('fields', 'name'));
   }
 
   public function getDataURI() {
     return idxv($this->parameters, array('fields', 'dataURI'));
   }
 
   public function getSize() {
     return idxv($this->parameters, array('fields', 'size'));
   }
 
   public function getURI() {
     $uri = idxv($this->parameters, array('fields', 'uri'));
 
     if ($uri === null) {
       $uri = '/'.$this->getMonogram();
     }
 
     return $uri;
   }
 
   public function getMonogram() {
     return 'F'.$this->getID();
   }
 
-  public function getDisplayRefObjectName() {
-    return $this->getMonogram();
-  }
-
-  public function getDisplayRefTitle() {
-    return $this->getName();
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getMonogram())
+      ->setTitle($this->getName());
   }
 
 }
diff --git a/src/ref/paste/ArcanistPasteRef.php b/src/ref/paste/ArcanistPasteRef.php
index 2c4bb58d..bfeaa77b 100644
--- a/src/ref/paste/ArcanistPasteRef.php
+++ b/src/ref/paste/ArcanistPasteRef.php
@@ -1,58 +1,54 @@
 <?php
 
 final class ArcanistPasteRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   private $parameters;
 
   public function getRefDisplayName() {
     return pht('Paste "%s"', $this->getMonogram());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getTitle() {
     return idxv($this->parameters, array('fields', 'title'));
   }
 
   public function getURI() {
     $uri = idxv($this->parameters, array('fields', 'uri'));
 
     if ($uri === null) {
       $uri = '/'.$this->getMonogram();
     }
 
     return $uri;
   }
 
   public function getContent() {
     return idxv($this->parameters, array('attachments', 'content', 'content'));
   }
 
   public function getMonogram() {
     return 'P'.$this->getID();
   }
 
-  public function getDisplayRefObjectName() {
-    return $this->getMonogram();
-  }
-
-  public function getDisplayRefTitle() {
-    return $this->getTitle();
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getMonogram())
+      ->setTitle($this->getName());
   }
 
 }
diff --git a/src/ref/revision/ArcanistRevisionRef.php b/src/ref/revision/ArcanistRevisionRef.php
index c507baa4..8e73dec2 100644
--- a/src/ref/revision/ArcanistRevisionRef.php
+++ b/src/ref/revision/ArcanistRevisionRef.php
@@ -1,178 +1,174 @@
 <?php
 
 final class ArcanistRevisionRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   const HARDPOINT_COMMITMESSAGE = 'ref.revision.commitmessage';
   const HARDPOINT_AUTHORREF = 'ref.revision.authorRef';
   const HARDPOINT_BUILDABLEREF = 'ref.revision.buildableRef';
   const HARDPOINT_PARENTREVISIONREFS = 'ref.revision.parentRevisionRefs';
 
   private $parameters;
   private $sources = array();
 
   public function getRefDisplayName() {
     return pht('Revision %s', $this->getMonogram());
   }
 
   protected function newHardpoints() {
     $object_list = new ArcanistObjectListHardpoint();
     return array(
       $this->newHardpoint(self::HARDPOINT_COMMITMESSAGE),
       $this->newHardpoint(self::HARDPOINT_AUTHORREF),
       $this->newHardpoint(self::HARDPOINT_BUILDABLEREF),
       $this->newTemplateHardpoint(
         self::HARDPOINT_PARENTREVISIONREFS,
         $object_list),
     );
   }
 
   public static function newFromConduit(array $dict) {
     $ref = new self();
     $ref->parameters = $dict;
     return $ref;
   }
 
   public static function newFromConduitQuery(array $dict) {
     // Mangle an older "differential.query" result to look like a modern
     // "differential.revision.search" result.
 
     $status_name = idx($dict, 'statusName');
 
     switch ($status_name) {
       case 'Abandoned':
       case 'Closed':
         $is_closed = true;
         break;
       default:
         $is_closed = false;
         break;
     }
 
     $dict['fields'] = array(
       'uri' => idx($dict, 'uri'),
       'title' => idx($dict, 'title'),
       'authorPHID' => idx($dict, 'authorPHID'),
       'status' => array(
         'name' => $status_name,
         'closed' => $is_closed,
       ),
     );
 
     return self::newFromConduit($dict);
   }
 
   public function getMonogram() {
     return 'D'.$this->getID();
   }
 
   public function getStatusDisplayName() {
     return idxv($this->parameters, array('fields', 'status', 'name'));
   }
 
   public function getStatusANSIColor() {
     return idxv($this->parameters, array('fields', 'status', 'color.ansi'));
   }
 
   public function isStatusChangesPlanned() {
     $status = $this->getStatus();
     return ($status === 'changes-planned');
   }
 
   public function isStatusAbandoned() {
     $status = $this->getStatus();
     return ($status === 'abandoned');
   }
 
   public function isStatusPublished() {
     $status = $this->getStatus();
     return ($status === 'published');
   }
 
   public function isStatusAccepted() {
     $status = $this->getStatus();
     return ($status === 'accepted');
   }
 
   public function getStatus() {
     return idxv($this->parameters, array('fields', 'status', 'value'));
   }
 
   public function isClosed() {
     return idxv($this->parameters, array('fields', 'status', 'closed'));
   }
 
   public function getURI() {
     $uri = idxv($this->parameters, array('fields', 'uri'));
 
     if ($uri === null) {
       // TODO: The "uri" field was added at the same time as this callsite,
       // so we may not have it yet if the server is running an older version
       // of Phabricator. Fake our way through.
 
       $uri = '/'.$this->getMonogram();
     }
 
     return $uri;
   }
 
   public function getFullName() {
     return pht('%s: %s', $this->getMonogram(), $this->getName());
   }
 
   public function getID() {
     return (int)idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getDiffPHID() {
     return idxv($this->parameters, array('fields', 'diffPHID'));
   }
 
   public function getName() {
     return idxv($this->parameters, array('fields', 'title'));
   }
 
   public function getAuthorPHID() {
     return idxv($this->parameters, array('fields', 'authorPHID'));
   }
 
   public function addSource(ArcanistRevisionRefSource $source) {
     $this->sources[] = $source;
     return $this;
   }
 
   public function getSources() {
     return $this->sources;
   }
 
   public function getCommitMessage() {
     return $this->getHardpoint(self::HARDPOINT_COMMITMESSAGE);
   }
 
   public function getAuthorRef() {
     return $this->getHardpoint(self::HARDPOINT_AUTHORREF);
   }
 
   public function getParentRevisionRefs() {
     return $this->getHardpoint(self::HARDPOINT_PARENTREVISIONREFS);
   }
 
   public function getBuildableRef() {
     return $this->getHardpoint(self::HARDPOINT_BUILDABLEREF);
   }
 
-  public function getDisplayRefObjectName() {
-    return $this->getMonogram();
-  }
-
-  public function getDisplayRefTitle() {
-    return $this->getName();
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getMonogram())
+      ->setTitle($this->getTitle());
   }
 
 }
diff --git a/src/ref/task/ArcanistTaskRef.php b/src/ref/task/ArcanistTaskRef.php
index d446b8df..ac918f77 100644
--- a/src/ref/task/ArcanistTaskRef.php
+++ b/src/ref/task/ArcanistTaskRef.php
@@ -1,44 +1,40 @@
 <?php
 
 final class ArcanistTaskRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   private $parameters;
 
   public function getRefDisplayName() {
     return pht('Task "%s"', $this->getMonogram());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getName() {
     return idxv($this->parameters, array('fields', 'name'));
   }
 
   public function getMonogram() {
     return 'T'.$this->getID();
   }
 
-  public function getDisplayRefObjectName() {
-    return $this->getMonogram();
-  }
-
-  public function getDisplayRefTitle() {
-    return $this->getName();
+  protected function buildRefView(ArcanistRefView $view) {
+    $view
+      ->setObjectName($this->getMonogram())
+      ->setTitle($this->getName());
   }
 
 }
diff --git a/src/ref/user/ArcanistUserRef.php b/src/ref/user/ArcanistUserRef.php
index 0d27ca6b..d430682d 100644
--- a/src/ref/user/ArcanistUserRef.php
+++ b/src/ref/user/ArcanistUserRef.php
@@ -1,66 +1,62 @@
 <?php
 
 final class ArcanistUserRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   private $parameters;
 
   public function getRefDisplayName() {
     return pht('User "%s"', $this->getMonogram());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public static function newFromConduitWhoami(array $parameters) {
     // NOTE: The "user.whoami" call returns a different structure than
     // "user.search". Mangle the data so it looks similar.
 
     $parameters['fields'] = array(
       'username' => idx($parameters, 'userName'),
       'realName' => idx($parameters, 'realName'),
     );
 
     return self::newFromConduit($parameters);
   }
 
   public function getID() {
     return idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   public function getMonogram() {
     return '@'.$this->getUsername();
   }
 
   public function getUsername() {
     return idxv($this->parameters, array('fields', 'username'));
   }
 
   public function getRealName() {
     return idxv($this->parameters, array('fields', 'realName'));
   }
 
-  public function getDisplayRefObjectName() {
-    return $this->getMonogram();
-  }
-
-  public function getDisplayRefTitle() {
+  protected function buildRefView(ArcanistRefView $view) {
     $real_name = $this->getRealName();
-
     if (strlen($real_name)) {
       $real_name = sprintf('(%s)', $real_name);
     }
 
-    return $real_name;
+    $view
+      ->setObjectName($this->getMonogram())
+      ->setTitle($real_name);
   }
 
+
 }
diff --git a/src/repository/marker/ArcanistMarkerRef.php b/src/repository/marker/ArcanistMarkerRef.php
index 77112b1e..a945d572 100644
--- a/src/repository/marker/ArcanistMarkerRef.php
+++ b/src/repository/marker/ArcanistMarkerRef.php
@@ -1,180 +1,176 @@
 <?php
 
 final class ArcanistMarkerRef
-  extends ArcanistRef
-  implements
-    ArcanistDisplayRefInterface {
+  extends ArcanistRef {
 
   const HARDPOINT_COMMITREF = 'arc.marker.commitRef';
   const HARDPOINT_WORKINGCOPYSTATEREF = 'arc.marker.workingCopyStateRef';
   const HARDPOINT_REMOTEREF = 'arc.marker.remoteRef';
 
   const TYPE_BRANCH = 'branch';
   const TYPE_BOOKMARK = 'bookmark';
 
   private $name;
   private $markerType;
   private $epoch;
   private $markerHash;
   private $commitHash;
   private $displayHash;
   private $treeHash;
   private $summary;
   private $message;
   private $isActive = false;
 
   public function getRefDisplayName() {
-    return $this->getDisplayRefObjectName();
-  }
-
-  public function getDisplayRefObjectName() {
     switch ($this->getMarkerType()) {
       case self::TYPE_BRANCH:
         return pht('Branch "%s"', $this->getName());
       case self::TYPE_BOOKMARK:
         return pht('Bookmark "%s"', $this->getName());
       default:
         return pht('Marker "%s"', $this->getName());
     }
   }
 
-  public function getDisplayRefTitle() {
-    return pht(
-      '%s %s',
-      $this->getDisplayHash(),
-      $this->getSummary());
-  }
-
   protected function newHardpoints() {
     return array(
       $this->newHardpoint(self::HARDPOINT_COMMITREF),
       $this->newHardpoint(self::HARDPOINT_WORKINGCOPYSTATEREF),
       $this->newHardpoint(self::HARDPOINT_REMOTEREF),
     );
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function setMarkerType($marker_type) {
     $this->markerType = $marker_type;
     return $this;
   }
 
   public function getMarkerType() {
     return $this->markerType;
   }
 
   public function setEpoch($epoch) {
     $this->epoch = $epoch;
     return $this;
   }
 
   public function getEpoch() {
     return $this->epoch;
   }
 
   public function setMarkerHash($marker_hash) {
     $this->markerHash = $marker_hash;
     return $this;
   }
 
   public function getMarkerHash() {
     return $this->markerHash;
   }
 
   public function setDisplayHash($display_hash) {
     $this->displayHash = $display_hash;
     return $this;
   }
 
   public function getDisplayHash() {
     return $this->displayHash;
   }
 
-
-
   public function setCommitHash($commit_hash) {
     $this->commitHash = $commit_hash;
     return $this;
   }
 
   public function getCommitHash() {
     return $this->commitHash;
   }
 
   public function setTreeHash($tree_hash) {
     $this->treeHash = $tree_hash;
     return $this;
   }
 
   public function getTreeHash() {
     return $this->treeHash;
   }
 
   public function setSummary($summary) {
     $this->summary = $summary;
     return $this;
   }
 
   public function getSummary() {
     return $this->summary;
   }
 
   public function setMessage($message) {
     $this->message = $message;
     return $this;
   }
 
   public function getMessage() {
     return $this->message;
   }
 
   public function setIsActive($is_active) {
     $this->isActive = $is_active;
     return $this;
   }
 
   public function getIsActive() {
     return $this->isActive;
   }
 
   public function isBookmark() {
     return ($this->getMarkerType() === self::TYPE_BOOKMARK);
   }
 
   public function isBranch() {
     return ($this->getMarkerType() === self::TYPE_BRANCH);
   }
 
   public function attachCommitRef(ArcanistCommitRef $ref) {
     return $this->attachHardpoint(self::HARDPOINT_COMMITREF, $ref);
   }
 
   public function getCommitRef() {
     return $this->getHardpoint(self::HARDPOINT_COMMITREF);
   }
 
   public function attachWorkingCopyStateRef(ArcanistWorkingCopyStateRef $ref) {
     return $this->attachHardpoint(self::HARDPOINT_WORKINGCOPYSTATEREF, $ref);
   }
 
   public function getWorkingCopyStateRef() {
     return $this->getHardpoint(self::HARDPOINT_WORKINGCOPYSTATEREF);
   }
 
   public function attachRemoteRef(ArcanistRemoteRef $ref = null) {
     return $this->attachHardpoint(self::HARDPOINT_REMOTEREF, $ref);
   }
 
   public function getRemoteRef() {
     return $this->getHardpoint(self::HARDPOINT_REMOTEREF);
   }
 
+  protected function buildRefView(ArcanistRefView $view) {
+    $title = pht(
+      '%s %s',
+      $this->getDisplayHash(),
+      $this->getSummary());
+
+    $view
+      ->setObjectName($this->getRefDisplayName())
+      ->setTitle($title);
+  }
+
 }
diff --git a/src/work/ArcanistWorkEngine.php b/src/work/ArcanistWorkEngine.php
index 0d8a01ed..531270b8 100644
--- a/src/work/ArcanistWorkEngine.php
+++ b/src/work/ArcanistWorkEngine.php
@@ -1,215 +1,215 @@
 <?php
 
 abstract class ArcanistWorkEngine
   extends ArcanistWorkflowEngine {
 
   private $symbolArgument;
   private $startArgument;
 
   final public function setSymbolArgument($symbol_argument) {
     $this->symbolArgument = $symbol_argument;
     return $this;
   }
 
   final public function getSymbolArgument() {
     return $this->symbolArgument;
   }
 
   final public function setStartArgument($start_argument) {
     $this->startArgument = $start_argument;
     return $this;
   }
 
   final public function getStartArgument() {
     return $this->startArgument;
   }
 
   final public function execute() {
     $workflow = $this->getWorkflow();
     $api = $this->getRepositoryAPI();
 
     $local_state = $api->newLocalState()
       ->setWorkflow($workflow)
       ->saveLocalState();
 
     $symbol = $this->getSymbolArgument();
 
     $markers = $api->newMarkerRefQuery()
       ->withNames(array($symbol))
       ->execute();
 
     if ($markers) {
       if (count($markers) > 1) {
 
         // TODO: This almost certainly means the symbol is a Mercurial branch
         // with multiple heads. We can pick some head.
 
         throw new PhutilArgumentUsageException(
           pht(
             'Symbol "%s" is ambiguous.',
             $symbol));
       }
 
       $target = head($markers);
       $this->moveToMarker($target);
       $local_state->discardLocalState();
       return;
     }
 
     $revision_marker = $this->workOnRevision($symbol);
     if ($revision_marker) {
       $this->moveToMarker($revision_marker);
       $local_state->discardLocalState();
       return;
     }
 
     $task_marker = $this->workOnTask($symbol);
     if ($task_marker) {
       $this->moveToMarker($task_marker);
       $local_state->discardLocalState();
       return;
     }
 
     // NOTE: We're resolving this symbol so we can raise an error message if
     // it's bogus, but we're using the symbol (not the resolved version) to
     // actually create the new marker. This matters in Git because it impacts
     // the behavior of "--track" when we pass a branch name.
 
     $start = $this->getStartArgument();
     if ($start !== null) {
       $start_commit = $api->getCanonicalRevisionName($start);
       if (!$start_commit) {
         throw new PhutilArgumentUsageException(
           pht(
             'Unable to resolve startpoint "%s".',
             $start));
       }
     } else {
       $start = $this->getDefaultStartSymbol();
     }
 
     $this->newMarker($symbol, $start);
     $local_state->discardLocalState();
   }
 
   abstract protected function newMarker($symbol, $start);
   abstract protected function moveToMarker(ArcanistMarkerRef $marker);
   abstract protected function getDefaultStartSymbol();
 
   private function workOnRevision($symbol) {
     $workflow = $this->getWorkflow();
     $api = $this->getRepositoryAPI();
     $log = $this->getLogEngine();
 
     try {
       $revision_symbol = id(new ArcanistRevisionSymbolRef())
         ->setSymbol($symbol);
     } catch (Exception $ex) {
       return;
     }
 
     $workflow->loadHardpoints(
       $revision_symbol,
       ArcanistSymbolRef::HARDPOINT_OBJECT);
 
     $revision_ref = $revision_symbol->getObject();
     if (!$revision_ref) {
       throw new PhutilArgumentUsageException(
         pht(
           'No revision "%s" exists, or you do not have permission to '.
           'view it.',
           $symbol));
     }
 
     $markers = $api->newMarkerRefQuery()
       ->execute();
 
     $state_refs = mpull($markers, 'getWorkingCopyStateRef');
 
     $workflow->loadHardpoints(
       $state_refs,
       ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS);
 
     $selected = array();
     foreach ($markers as $marker) {
       $state_ref = $marker->getWorkingCopyStateRef();
       $revision_refs = $state_ref->getRevisionRefs();
       $revision_refs = mpull($revision_refs, null, 'getPHID');
 
       if (isset($revision_refs[$revision_ref->getPHID()])) {
         $selected[] = $marker;
       }
     }
 
     if (!$selected) {
 
       // TODO: We could patch/load here.
 
       throw new PhutilArgumentUsageException(
         pht(
           'Revision "%s" was not found anywhere in this working copy.',
           $revision_ref->getMonogram()));
     }
 
     if (count($selected) > 1) {
       $selected = msort($selected, 'getEpoch');
 
       echo tsprintf(
         "\n%!\n%W\n\n",
         pht('AMBIGUOUS MARKER'),
         pht(
           'More than one marker in the local working copy is associated '.
           'with the revision "%s", using the most recent one.',
           $revision_ref->getMonogram()));
 
       foreach ($selected as $marker) {
-        echo tsprintf('%s', $marker->newDisplayRef());
+        echo tsprintf('%s', $marker->newRefView());
       }
 
       echo tsprintf("\n");
 
       $target = last($selected);
     } else {
       $target = head($selected);
     }
 
     $log->writeStatus(
       pht('REVISION'),
       pht('Resuming work on revision:'));
 
-    echo tsprintf('%s', $revision_ref->newDisplayRef());
+    echo tsprintf('%s', $revision_ref->newRefView());
     echo tsprintf("\n");
 
     return $target;
   }
 
   private function workOnTask($symbol) {
     $workflow = $this->getWorkflow();
 
     try {
       $task_symbol = id(new ArcanistTaskSymbolRef())
         ->setSymbol($symbol);
     } catch (Exception $ex) {
       return;
     }
 
     $workflow->loadHardpoints(
       $task_symbol,
       ArcanistSymbolRef::HARDPOINT_OBJECT);
 
     $task_ref = $task_symbol->getObject();
     if (!$task_ref) {
       throw new PhutilArgumentUsageException(
         pht(
           'No task "%s" exists, or you do not have permission to view it.',
           $symbol));
     }
 
     throw new Exception(pht('TODO: Implement this workflow.'));
 
     $this->loadHardpoints(
       $task_ref,
       ArcanistTaskRef::HARDPOINT_REVISIONREFS);
   }
 
 }
diff --git a/src/workflow/ArcanistAmendWorkflow.php b/src/workflow/ArcanistAmendWorkflow.php
index be1cf25f..33288852 100644
--- a/src/workflow/ArcanistAmendWorkflow.php
+++ b/src/workflow/ArcanistAmendWorkflow.php
@@ -1,278 +1,278 @@
 <?php
 
 final class ArcanistAmendWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'amend';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 Amend the working copy, synchronizing the local commit message from
 Differential.
 
 Supported in Mercurial 2.2 and newer.
 EOTEXT
       );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(
         pht('Amend the working copy, synchronizing the local commit message.'))
       ->addExample('**amend** [options] -- ')
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('show')
         ->setHelp(
           pht(
             'Show the amended commit message, without modifying the '.
             'working copy.')),
       $this->newWorkflowArgument('revision')
         ->setParameter('id')
         ->setHelp(
           pht(
             'Use the message from a specific revision. If you do not specify '.
             'a revision, arc will guess which revision is in the working '.
             'copy.')),
     );
   }
 
   protected function newPrompts() {
     return array(
       $this->newPrompt('arc.amend.unrelated')
         ->setDescription(
           pht(
             'Confirms use of a revision that does not appear to be '.
             'present in the working copy.')),
       $this->newPrompt('arc.amend.author')
         ->setDescription(
           pht(
             'Confirms use of a revision that you are not the author '.
             'of.')),
       $this->newPrompt('arc.amend.immutable')
         ->setDescription(
           pht(
             'Confirms history mutation in a working copy marked as '.
             'immutable.')),
     );
   }
 
   public function runWorkflow() {
     $symbols = $this->getSymbolEngine();
 
     $is_show = $this->getArgument('show');
 
     $repository_api = $this->getRepositoryAPI();
     if (!$is_show) {
       $this->requireAmendSupport($repository_api);
     }
 
     $revision_symbol = $this->getArgument('revision');
 
     // We only care about the local working copy state if we need it to
     // figure out which revision we're operating on, or we're planning to
     // mutate it. If the caller is running "arc amend --show --revision X",
     // the local state does not matter.
 
     $need_state =
       ($revision_symbol === null) ||
       (!$is_show);
 
     if ($need_state) {
       $state_ref = $repository_api->getCurrentWorkingCopyStateRef();
 
       $this->loadHardpoints(
         $state_ref,
         ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS);
 
       $revision_refs = $state_ref->getRevisionRefs();
     }
 
     if ($revision_symbol === null) {
       $revision_ref = $this->selectRevisionRef($revision_refs);
     } else {
       $revision_ref = $symbols->loadRevisionForSymbol($revision_symbol);
       if (!$revision_ref) {
         throw new PhutilArgumentUsageException(
           pht(
             'Revision "%s" does not exist, or you do not have permission '.
             'to see it.',
             $revision_symbol));
       }
     }
 
     if (!$is_show) {
       echo tsprintf(
         "%s\n\n%s\n",
         pht('Amending commit message to reflect revision:'),
-        $revision_ref->newDisplayRef());
+        $revision_ref->newRefView());
 
       $this->confirmAmendAuthor($revision_ref);
       $this->confirmAmendNotFound($revision_ref, $state_ref);
     }
 
     $this->loadHardpoints(
       $revision_ref,
       ArcanistRevisionRef::HARDPOINT_COMMITMESSAGE);
 
     $message = $revision_ref->getCommitMessage();
 
     if ($is_show) {
       echo tsprintf(
         "%B\n",
         $message);
     } else {
       $repository_api->amendCommit($message);
     }
 
     return 0;
   }
 
   private function requireAmendSupport(ArcanistRepositoryAPI $api) {
     if (!$api->supportsAmend()) {
       if ($api instanceof ArcanistMercurialAPI) {
         throw new PhutilArgumentUsageException(
           pht(
             '"arc amend" is only supported under Mercurial 2.2 or newer. '.
             'Older versions of Mercurial do not support the "--amend" flag '.
             'to "hg commit ...", which this workflow requires.'));
       }
 
       throw new PhutilArgumentUsageException(
         pht(
           '"arc amend" must be run from inside a working copy of a '.
           'repository using a version control system that supports '.
           'amending commits, like Git or Mercurial.'));
     }
 
     if ($this->isHistoryImmutable()) {
       echo tsprintf(
         "%!\n\n%W\n",
         pht('IMMUTABLE WORKING COPY'),
         pht(
           'This working copy is configured to have an immutable local '.
           'history, using the "history.immutable" configuration option. '.
           'Amending the working copy will mutate local history.'));
 
       $prompt = pht('Are you sure you want to mutate history?');
 
       $this->getPrompt('arc.amend.immutable')
         ->setQuery($prompt)
         ->execute();
     }
 
     return;
 
     if ($api->getUncommittedChanges()) {
       // TODO: Make this class of error show the uncommitted changes.
 
       // TODO: This only needs to check for staged-but-uncommitted changes.
       // We can safely amend with untracked and unstaged changes.
 
       throw new PhutilArgumentUsageException(
         pht(
           'You have uncommitted changes in this working copy. Commit or '.
           'revert them before proceeding.'));
     }
   }
 
   private function selectRevisionRef(array $revisions) {
     if (!$revisions) {
       throw new PhutilArgumentUsageException(
         pht(
           'No revision specified with "--revision", and no revisions found '.
           'that match the current working copy state. Use "--revision <id>" '.
           'to specify which revision you want to amend.'));
     }
 
      if (count($revisions) > 1) {
        echo tsprintf(
          "%!\n%W\n\n%B\n",
          pht('MULTIPLE REVISIONS IN WORKING COPY'),
          pht('More than one revision was found in the working copy:'),
-         mpull($revisions, 'newDisplayRef'));
+         mpull($revisions, 'newRefView'));
 
       throw new PhutilArgumentUsageException(
         pht(
           'Use "--revision <id>" to specify which revision you want '.
           'to amend.'));
     }
 
     return head($revisions);
   }
 
   private function confirmAmendAuthor(ArcanistRevisionRef $revision_ref) {
     $viewer = $this->getViewer();
     $viewer_phid = $viewer->getPHID();
 
     $author_phid = $revision_ref->getAuthorPHID();
 
     if ($viewer_phid === $author_phid) {
       return;
     }
 
     $symbols = $this->getSymbolEngine();
     $author_ref = $symbols->loadUserForSymbol($author_phid);
     if (!$author_ref) {
       // If we don't have any luck loading the author, skip this warning.
       return;
     }
 
     echo tsprintf(
       "%!\n\n%W\n\n%s",
       pht('NOT REVISION AUTHOR'),
       array(
         pht(
           'You are amending the working copy using information from '.
           'a revision you are not the author of.'),
         "\n\n",
         pht(
           'The author of this revision (%s) is:',
           $revision_ref->getMonogram()),
       ),
-      $author_ref->newDisplayRef());
+      $author_ref->newRefView());
 
     $prompt = pht(
       'Amend working copy using revision owned by %s?',
       $author_ref->getMonogram());
 
     $this->getPrompt('arc.amend.author')
       ->setQuery($prompt)
       ->execute();
   }
 
   private function confirmAmendNotFound(
     ArcanistRevisionRef $revision_ref,
     ArcanistWorkingCopyStateRef $state_ref) {
 
     $local_refs = $state_ref->getRevisionRefs();
     $local_refs = mpull($local_refs, null, 'getPHID');
 
     $revision_phid = $revision_ref->getPHID();
     $is_local = isset($local_refs[$revision_phid]);
 
     if ($is_local) {
       return;
     }
 
     echo tsprintf(
       "%!\n\n%W\n",
       pht('UNRELATED REVISION'),
       pht(
         'You are amending the working copy using information from '.
         'a revision that does not appear to be associated with the '.
         'current state of the working copy.'));
 
     $prompt = pht(
       'Amend working copy using unrelated revision %s?',
       $revision_ref->getMonogram());
 
     $this->getPrompt('arc.amend.unrelated')
       ->setQuery($prompt)
       ->execute();
   }
 
 }
diff --git a/src/workflow/ArcanistPasteWorkflow.php b/src/workflow/ArcanistPasteWorkflow.php
index 24468e7a..f9e2a693 100644
--- a/src/workflow/ArcanistPasteWorkflow.php
+++ b/src/workflow/ArcanistPasteWorkflow.php
@@ -1,172 +1,172 @@
 <?php
 
 final class ArcanistPasteWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'paste';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 Share and grab text using the Paste application. To create a paste, use the
 "--input" flag or provide the text on stdin:
 
   $ cat list_of_ducks.txt | arc paste
   $ arc paste --input list_of_ducks.txt
 
 To retrieve a paste, specify the paste ID:
 
   $ arc paste P123
 EOTEXT
       );
 
     return $this->newWorkflowInformation()
       ->addExample('**paste** [__options__] --')
       ->addExample('**paste** [__options__] -- __object__')
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('title')
         ->setParameter('title')
         ->setHelp(pht('Title for the paste.')),
       $this->newWorkflowArgument('lang')
         ->setParameter('language')
         ->setHelp(pht('Language for the paste.')),
       $this->newWorkflowArgument('input')
         ->setParameter('path')
         ->setIsPathArgument(true)
         ->setHelp(pht('Create a paste using the content in a file.')),
       $this->newWorkflowArgument('browse')
         ->setHelp(pht('After creating a paste, open it in a web browser.')),
       $this->newWorkflowArgument('argv')
         ->setWildcard(true),
     );
   }
 
   public function runWorkflow() {
     $set_language = $this->getArgument('lang');
     $set_title = $this->getArgument('title');
     $is_browse = $this->getArgument('browse');
     $input_path = $this->getArgument('input');
 
     $argv = $this->getArgument('argv');
     if (count($argv) > 1) {
       throw new PhutilArgumentUsageException(
         pht(
           'Specify only one paste to retrieve.'));
     }
 
     $is_read = (count($argv) === 1);
 
     $symbols = $this->getSymbolEngine();
 
     if (count($argv) === 1) {
       if ($set_language !== null) {
         throw new PhutilArgumentUsageException(
           pht(
             'Flag "--lang" is not supported when reading pastes.'));
       }
 
       if ($set_title !== null) {
         throw new PhutilArgumentUsageException(
           pht(
             'Flag "--title" is not supported when reading pastes.'));
       }
 
       if ($is_browse) {
         throw new PhutilArgumentUsageException(
           pht(
             'Flag "--browse" is not supported when reading pastes. Use '.
             '"arc browse" to browse known objects.'));
       }
 
       if ($input_path !== null) {
         throw new PhutilArgumentUsageException(
           pht(
             'Flag "--input" is not supported when reading pastes.'));
       }
 
       $paste_symbol = $argv[0];
 
       $paste_ref = $symbols->loadPasteForSymbol($paste_symbol);
       if (!$paste_ref) {
         throw new PhutilArgumentUsageException(
           pht(
             'Paste "%s" does not exist, or you do not have access '.
             'to see it.',
             $paste_symbol));
       }
 
       echo $paste_ref->getContent();
 
       return 0;
     }
 
     if ($input_path === null || $input_path === '-') {
       $content = $this->readStdin();
     } else {
       $content = Filesystem::readFile($input_path);
     }
 
     $xactions = array();
 
     if ($set_title === null) {
       $set_title = pht('Command-Line Input');
     }
 
     $xactions[] = array(
       'type' => 'title',
       'value' => $set_title,
     );
 
     if ($set_language !== null) {
       $xactions[] = array(
         'type' => 'language',
         'value' => $set_language,
       );
     }
 
     $xactions[] = array(
       'type' => 'text',
       'value' => $content,
     );
 
     $method = 'paste.edit';
 
     $parameters = array(
       'transactions' => $xactions,
     );
 
     $conduit_engine = $this->getConduitEngine();
     $conduit_call = $conduit_engine->newCall($method, $parameters);
     $conduit_future = $conduit_engine->newFuture($conduit_call);
     $result = $conduit_future->resolve();
 
     $paste_phid = idxv($result, array('object', 'phid'));
     $paste_ref = $symbols->loadPasteForSymbol($paste_phid);
 
     $uri = $paste_ref->getURI();
     $uri = $this->getAbsoluteURI($uri);
 
     $log = $this->getLogEngine();
 
     $log->writeSuccess(
       pht('DONE'),
       pht('Created a new paste.'));
 
     echo tsprintf(
       '%s',
-      $paste_ref->newDisplayRef()
+      $paste_ref->newRefView()
         ->setURI($uri));
 
     if ($is_browse) {
       $this->openURIsInBrowser(array($uri));
     }
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistUploadWorkflow.php b/src/workflow/ArcanistUploadWorkflow.php
index c9c9dd83..1ed34f46 100644
--- a/src/workflow/ArcanistUploadWorkflow.php
+++ b/src/workflow/ArcanistUploadWorkflow.php
@@ -1,223 +1,223 @@
 <?php
 
 final class ArcanistUploadWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'upload';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 Upload one or more files from local disk to Phabricator.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Upload files.'))
       ->addExample(pht('**upload** [__options__] -- __file__ [__file__ ...]'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('json')
         ->setHelp(pht('Output upload information in JSON format.')),
       $this->newWorkflowArgument('browse')
         ->setHelp(
           pht(
             'After the upload completes, open the files in a web browser.')),
       $this->newWorkflowArgument('temporary')
         ->setHelp(
           pht(
             'Mark the file as temporary. Temporary files will be '.
             'deleted after 24 hours.')),
       $this->newWorkflowArgument('paths')
         ->setWildcard(true)
         ->setIsPathArgument(true),
     );
   }
 
   public function runWorkflow() {
     if (!$this->getArgument('paths')) {
       throw new PhutilArgumentUsageException(
         pht('Specify one or more paths to files you want to upload.'));
     }
 
     $is_temporary = $this->getArgument('temporary');
     $is_json = $this->getArgument('json');
     $is_browse = $this->getArgument('browse');
     $paths = $this->getArgument('paths');
 
     $conduit = $this->getConduitEngine();
     $results = array();
 
     $uploader = id(new ArcanistFileUploader())
       ->setConduitEngine($conduit);
 
     foreach ($paths as $key => $path) {
       $file = id(new ArcanistFileDataRef())
         ->setName(basename($path))
         ->setPath($path);
 
       if ($is_temporary) {
         $expires_at = time() + phutil_units('24 hours in seconds');
         $file->setDeleteAfterEpoch($expires_at);
       }
 
       $uploader->addFile($file);
     }
 
     $files = $uploader->uploadFiles();
 
     $phids = array();
     foreach ($files as $file) {
       // TODO: This could be handled more gracefully.
       if ($file->getErrors()) {
         throw new Exception(implode("\n", $file->getErrors()));
       }
       $phids[] = $file->getPHID();
     }
 
     $symbols = $this->getSymbolEngine();
     $symbol_refs = $symbols->loadFilesForSymbols($phids);
 
     $refs = array();
     foreach ($symbol_refs as $symbol_ref) {
       $ref = $symbol_ref->getObject();
       if ($ref === null) {
         throw new Exception(
           pht(
             'Failed to resolve symbol ref "%s".',
             $symbol_ref->getSymbol()));
       }
       $refs[] = $ref;
     }
 
     if ($is_json) {
       $json = array();
 
       foreach ($refs as $key => $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
 
         $map = array(
           'argument' => $paths[$key],
           'id' => $ref->getID(),
           'phid' => $ref->getPHID(),
           'name' => $ref->getName(),
           'uri' => $uri,
         );
 
         $json[] = $map;
       }
 
       echo id(new PhutilJSON())->encodeAsList($json);
     } else {
       foreach ($refs as $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
         echo tsprintf(
           '%s',
-          $ref->newDisplayRef()
+          $ref->newRefView()
             ->setURI($uri));
       }
     }
 
     if ($is_browse) {
       $uris = array();
       foreach ($refs as $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
         $uris[] = $uri;
       }
       $this->openURIsInBrowser($uris);
     }
 
     return 0;
   }
 
   private function writeStatus($line) {
     $this->writeStatusMessage($line."\n");
   }
 
   private function uploadChunks($file_phid, $path) {
     $conduit = $this->getConduit();
 
     $f = @fopen($path, 'rb');
     if (!$f) {
       throw new Exception(pht('Unable to open file "%s"', $path));
     }
 
     $this->writeStatus(pht('Beginning chunked upload of large file...'));
     $chunks = $conduit->resolveCall(
       'file.querychunks',
       array(
         'filePHID' => $file_phid,
       ));
 
     $remaining = array();
     foreach ($chunks as $chunk) {
       if (!$chunk['complete']) {
         $remaining[] = $chunk;
       }
     }
 
     $done = (count($chunks) - count($remaining));
 
     if ($done) {
       $this->writeStatus(
         pht(
           'Resuming upload (%s of %s chunks remain).',
           phutil_count($remaining),
           phutil_count($chunks)));
     } else {
       $this->writeStatus(
         pht(
           'Uploading chunks (%s chunks to upload).',
           phutil_count($remaining)));
     }
 
     $progress = new PhutilConsoleProgressBar();
     $progress->setTotal(count($chunks));
 
     for ($ii = 0; $ii < $done; $ii++) {
       $progress->update(1);
     }
 
     $progress->draw();
 
     // TODO: We could do these in parallel to improve upload performance.
     foreach ($remaining as $chunk) {
       $offset = $chunk['byteStart'];
 
       $ok = fseek($f, $offset);
       if ($ok !== 0) {
         throw new Exception(
           pht(
             'Failed to %s!',
             'fseek()'));
       }
 
       $data = fread($f, $chunk['byteEnd'] - $chunk['byteStart']);
       if ($data === false) {
         throw new Exception(
           pht(
             'Failed to %s!',
             'fread()'));
       }
 
       $conduit->resolveCall(
         'file.uploadchunk',
         array(
           'filePHID' => $file_phid,
           'byteStart' => $offset,
           'dataEncoding' => 'base64',
           'data' => base64_encode($data),
         ));
 
       $progress->update(1);
     }
   }
 
 }