diff --git a/.gitignore b/.gitignore
index 53eeb426..096c30cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,32 +1,35 @@
 # NOTE: Thinking about adding files created by your operating system, IDE,
 # or text editor here? Don't! Add them to your per-user .gitignore instead.
 
 # Diviner
 /docs/
 /.divinercache/
 
 # libphutil
 /src/.phutil_module_cache
 
 # User extensions
 /externals/includes/*
 /src/extensions/*
 
 # XHPAST
 /support/xhpast/*.a
 /support/xhpast/*.o
 /support/xhpast/parser.yacc.output
 /support/xhpast/node_names.hpp
 /support/xhpast/xhpast
 /support/xhpast/xhpast.exe
 /src/parser/xhpast/bin/xhpast
 
 ## NOTE: Don't .gitignore these files! Even though they're build artifacts, we
 ## want to check them in so users can build xhpast without flex/bison.
 # /support/xhpast/parser.yacc.cpp
 # /support/xhpast/parser.yacc.hpp
 # /support/xhpast/scanner.lex.cpp
 # /support/xhpast/scanner.lex.hpp
 
 # This is an OS X build artifact.
 /support/xhpast/xhpast.dSYM
+
+# Generated shell completion rulesets.
+/support/shell/rules/
diff --git a/resources/shell/bash-completion b/resources/shell/bash-completion
deleted file mode 100644
index 0ba9ef48..00000000
--- a/resources/shell/bash-completion
+++ /dev/null
@@ -1,26 +0,0 @@
-if [[ -n ${ZSH_VERSION-} ]]; then
-  autoload -U +X bashcompinit && bashcompinit
-fi
-
-_arc ()
-{
-  CUR="${COMP_WORDS[COMP_CWORD]}"
-  COMPREPLY=()
-  OPTS=$(echo | arc shell-complete --current ${COMP_CWORD} -- ${COMP_WORDS[@]})
-
-  if [ $? -ne 0 ]; then
-    return $?
-  fi
-
-  if [ "$OPTS" = "FILE" ]; then
-    COMPREPLY=( $(compgen -f -- ${CUR}) )
-    return 0
-  fi
-
-  if [ "$OPTS" = "ARGUMENT" ]; then
-    return 0
-  fi
-
-  COMPREPLY=( $(compgen -W "${OPTS}" -- ${CUR}) )
-}
-complete -F _arc -o filenames arc
diff --git a/scripts/__init_script__.php b/scripts/__init_script__.php
index f6cdcc31..98de4ef9 100644
--- a/scripts/__init_script__.php
+++ b/scripts/__init_script__.php
@@ -1,3 +1,3 @@
 <?php
 
-require_once dirname(dirname(__FILE__)).'/scripts/init/init-script.php';
+require_once dirname(dirname(__FILE__)).'/support/init/init-script.php';
diff --git a/scripts/breakout.py b/scripts/breakout.py
index c8c8b188..0b473b84 100755
--- a/scripts/breakout.py
+++ b/scripts/breakout.py
@@ -1,220 +1,228 @@
 #!/usr/bin/env python2
 import sys
 import time
 import select
 import curses
 from curses import wrapper
 
 entities = []
 grid = []
 
 class Wall:
     def collide(self, ball):
         return False
 
 class Block:
     killed = 0
     total = 0
 
     def __init__(self, x, y, w, h, c):
         self.x = x
         self.y = y
         self.w = w
         self.h = h
         self.fmt = curses.A_BOLD | curses.color_pair(c)
         self.alive = True
         for i in range(self.x, self.x + self.w):
             for j in range(self.y, self.y + self.h):
                 grid[j + 1][i + 1] = self
         Block.total += 1
 
     def collide(self, ball):
         self.alive = False
         for i in range(self.x, self.x + self.w):
             for j in range(self.y, self.y + self.h):
                 grid[j + 1][i + 1] = None
         Block.killed += 1
         return False
 
     def tick(self, win):
         if self.alive:
             for i in range(self.x, self.x + self.w):
                 for j in range(self.y, self.y + self.h):
                     win.addch(j, i, curses.ACS_BLOCK, self.fmt)
         return self.alive
 
 class Ball:
     alive = False
     killed = 0
 
     def __init__(self, x, y, vx, vy):
         self.x = x
         self.y = y
         self.vx = vx
         self.vy = vy
         Ball.alive = True
 
     def collide(self, ball):
         return True
 
     def encounter(self, dx, dy):
         ent = grid[self.y + dy + 1][self.x + dx + 1]
         if ent and not ent.collide(self):
             self.vx -= 2 * dx
             self.vy -= 2 * dy
         return ent
 
     def tick(self, win):
         while self.y < ship.y:
             if self.encounter((self.vx + self.vy) / 2, (self.vy - self.vx) / 2):
                 continue
             if self.encounter((self.vx - self.vy) / 2, (self.vy + self.vx) / 2):
                 continue
             if self.encounter(self.vx, self.vy):
                 continue
             break
         self.x += self.vx
         self.y += self.vy
         try:
             win.addch(self.y, self.x, 'O')
         except curses.error:
             Ball.alive = False
             Ball.killed += 1
         return Ball.alive
 
 class Ship:
     def __init__(self, x, y):
         self.x = x
         self.y = y
         self.hw = 10
         self.v = 4
         self.last = 1
         self.update()
 
     def update(self):
         grid[self.y + 1] = (
             [ None ] * (self.x - self.hw + 1) +
             [ self ] * (self.hw * 2 + 1) +
             [ None ] * (width - self.x - self.hw)
         )
 
     def collide(self, ball):
         ball.vy = -1
         if ball.x > self.x + self.hw / 2:
             ball.vx = 1
         elif ball.x < self.x - self.hw / 2:
             ball.vx = -1
         return True
 
     def shift(self, i):
         self.last = i
         self.x += self.v * i
         if self.x - self.hw < 0:
             self.x = self.hw
         elif self.x + self.hw >= width:
             self.x = width - self.hw - 1
         self.update()
 
     def spawn(self):
         if not Ball.alive:
             entities.append(Ball(self.x, self.y - 1, self.last, -1))
 
     def tick(self, win):
         if not Ball.alive:
             win.addch(self.y - 1, self.x, 'O')
         win.addch(self.y, self.x - self.hw, curses.ACS_LTEE)
         for i in range(-self.hw + 1, self.hw):
             win.addch(curses.ACS_HLINE)
         win.addch(curses.ACS_RTEE)
         return True
 
 class PowerOverwhelmingException(Exception):
     pass
 
 def main(stdscr):
     global height, width, ship
 
     for i in range(1, 8):
         curses.init_pair(i, i, 0)
     curses.curs_set(0)
     curses.raw()
 
     height, width = stdscr.getmaxyx()
 
-    if height < 15 or width < 30:
+    if height < 15 or width < 32:
         raise PowerOverwhelmingException(
-            "Your computer is not powerful enough to run 'arc anoid'. "
-            "It must support at least 30 columns and 15 rows of next-gen "
-            "full-color 3D graphics.")
+            'Your computer is not powerful enough to run "arc anoid". '
+            'It must support at least 32 columns and 15 rows of next-gen '
+            'full-color 3D graphics.')
 
     status = curses.newwin(1, width, 0, 0)
     height -= 1
     game = curses.newwin(height, width, 1, 0)
     game.nodelay(1)
     game.keypad(1)
 
     grid[:] = [ [ None for x in range(width + 2) ] for y in range(height + 2) ]
     wall = Wall()
     for x in range(width + 2):
         grid[0][x] = wall
     for y in range(height + 2):
         grid[y][0] = grid[y][-1] = wall
     ship = Ship(width / 2, height - 5)
     entities.append(ship)
 
     colors = [ 1, 3, 2, 6, 4, 5 ]
     h = height / 10
     for x in range(1, width / 7 - 1):
         for y in range(1, 7):
             entities.append(Block(x * 7,
                                   y * h + x / 2 % 2,
                                   7,
                                   h,
                                   colors[y - 1]))
 
     while True:
         while select.select([ sys.stdin ], [], [], 0)[0]:
             key = game.getch()
             if key == curses.KEY_LEFT or key == ord('a') or key == ord('A'):
                 ship.shift(-1)
             elif key == curses.KEY_RIGHT or key == ord('d') or key == ord('D'):
                 ship.shift(1)
             elif key == ord(' '):
                 ship.spawn()
             elif key == 0x1b or key == 3 or key == ord('q') or key == ord('Q'):
                 return
 
         game.resize(height, width)
         game.erase()
         entities[:] = [ ent for ent in entities if ent.tick(game) ]
 
         status.hline(0, 0, curses.ACS_HLINE, width)
         status.addch(0, 2, curses.ACS_RTEE)
         status.addstr(' SCORE: ', curses.A_BOLD | curses.color_pair(4))
         status.addstr('%s/%s ' % (Block.killed, Block.total), curses.A_BOLD)
         status.addch(curses.ACS_VLINE)
         status.addstr(' DEATHS: ', curses.A_BOLD | curses.color_pair(4))
-        status.addstr('%s ' % Ball.killed, curses.A_BOLD)
+
+        # See T8693. At the minimum display size, we only have room to render
+        # two characters for the death count, so just display "99" if the
+        # player has more than 99 deaths.
+        display_deaths = Ball.killed
+        if (display_deaths > 99):
+            display_deaths = 99
+
+        status.addstr('%s ' % display_deaths, curses.A_BOLD)
         status.addch(curses.ACS_LTEE)
 
         if Block.killed == Block.total:
             message = ' A WINNER IS YOU!! '
             i = int(time.time() / 0.8)
             for x in range(width):
                 for y in range(6):
                     game.addch(height / 2 + y - 3 + (x / 8 + i) % 2, x,
                                curses.ACS_BLOCK,
                                curses.A_BOLD | curses.color_pair(colors[y]))
             game.addstr(height / 2, (width - len(message)) / 2, message,
                            curses.A_BOLD | curses.color_pair(7))
 
         game.refresh()
         status.refresh()
         time.sleep(0.05)
 
 try:
     curses.wrapper(main)
     print ('You destroyed %s blocks out of %s with %s deaths.' %
         (Block.killed, Block.total, Ball.killed))
 except PowerOverwhelmingException as e:
     print (e)
diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
index 2f9a3798..fe1e4178 100644
--- a/src/__phutil_library_map__.php
+++ b/src/__phutil_library_map__.php
@@ -1,1700 +1,1698 @@
 <?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',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAliasFunctionXHPASTLinterRule.php',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAliasFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistAliasWorkflow' => 'workflow/ArcanistAliasWorkflow.php',
     'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
     'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.php',
     'ArcanistArrayCombineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayCombineXHPASTLinterRule.php',
     'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayCombineXHPASTLinterRuleTestCase.php',
     'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayIndexSpacingXHPASTLinterRule.php',
     'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistArraySeparatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArraySeparatorXHPASTLinterRule.php',
     'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArraySeparatorXHPASTLinterRuleTestCase.php',
     'ArcanistArrayValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayValueXHPASTLinterRule.php',
     'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayValueXHPASTLinterRuleTestCase.php',
     'ArcanistBackoutWorkflow' => 'workflow/ArcanistBackoutWorkflow.php',
     'ArcanistBaseCommitParser' => 'parser/ArcanistBaseCommitParser.php',
     'ArcanistBaseCommitParserTestCase' => 'parser/__tests__/ArcanistBaseCommitParserTestCase.php',
     'ArcanistBaseXHPASTLinter' => 'lint/linter/ArcanistBaseXHPASTLinter.php',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryExpressionSpacingXHPASTLinterRule.php',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryNumericScalarCasingXHPASTLinterRule.php',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase.php',
     'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBlacklistedFunctionXHPASTLinterRule.php',
     'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistBlindlyTrustHTTPEngineExtension' => 'configuration/ArcanistBlindlyTrustHTTPEngineExtension.php',
     'ArcanistBookmarkWorkflow' => 'workflow/ArcanistBookmarkWorkflow.php',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBraceFormattingXHPASTLinterRule.php',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBraceFormattingXHPASTLinterRuleTestCase.php',
     'ArcanistBranchRef' => 'ref/ArcanistBranchRef.php',
     'ArcanistBranchWorkflow' => 'workflow/ArcanistBranchWorkflow.php',
     'ArcanistBrowseCommitHardpointLoader' => 'browse/loader/ArcanistBrowseCommitHardpointLoader.php',
     'ArcanistBrowseCommitURIHardpointLoader' => 'browse/loader/ArcanistBrowseCommitURIHardpointLoader.php',
     'ArcanistBrowseObjectNameURIHardpointLoader' => 'browse/loader/ArcanistBrowseObjectNameURIHardpointLoader.php',
     'ArcanistBrowsePathURIHardpointLoader' => 'browse/loader/ArcanistBrowsePathURIHardpointLoader.php',
     'ArcanistBrowseRef' => 'browse/ref/ArcanistBrowseRef.php',
     'ArcanistBrowseRevisionURIHardpointLoader' => 'browse/loader/ArcanistBrowseRevisionURIHardpointLoader.php',
     'ArcanistBrowseURIHardpointLoader' => 'browse/loader/ArcanistBrowseURIHardpointLoader.php',
     'ArcanistBrowseURIRef' => 'browse/ref/ArcanistBrowseURIRef.php',
     'ArcanistBrowseWorkflow' => 'browse/workflow/ArcanistBrowseWorkflow.php',
     'ArcanistBuildPlanRef' => 'ref/ArcanistBuildPlanRef.php',
     'ArcanistBuildRef' => 'ref/ArcanistBuildRef.php',
     'ArcanistBundle' => 'parser/ArcanistBundle.php',
     'ArcanistBundleTestCase' => 'parser/__tests__/ArcanistBundleTestCase.php',
     'ArcanistCSSLintLinter' => 'lint/linter/ArcanistCSSLintLinter.php',
     'ArcanistCSSLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCSSLintLinterTestCase.php',
     'ArcanistCSharpLinter' => 'lint/linter/ArcanistCSharpLinter.php',
     'ArcanistCallConduitWorkflow' => 'workflow/ArcanistCallConduitWorkflow.php',
     'ArcanistCallParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallParenthesesXHPASTLinterRule.php',
     'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallTimePassByReferenceXHPASTLinterRule.php',
     'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistCapabilityNotSupportedException' => 'workflow/exception/ArcanistCapabilityNotSupportedException.php',
     'ArcanistCastSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCastSpacingXHPASTLinterRule.php',
     'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCastSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistCheckstyleXMLLintRenderer' => 'lint/renderer/ArcanistCheckstyleXMLLintRenderer.php',
     'ArcanistChmodLinter' => 'lint/linter/ArcanistChmodLinter.php',
     'ArcanistChmodLinterTestCase' => 'lint/linter/__tests__/ArcanistChmodLinterTestCase.php',
     'ArcanistClassExtendsObjectXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassExtendsObjectXHPASTLinterRule.php',
     'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassExtendsObjectXHPASTLinterRuleTestCase.php',
     'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassFilenameMismatchXHPASTLinterRule.php',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule.php',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase.php',
     'ArcanistClassNameLiteralXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassNameLiteralXHPASTLinterRule.php',
     'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassNameLiteralXHPASTLinterRuleTestCase.php',
     'ArcanistCloseRevisionWorkflow' => 'workflow/ArcanistCloseRevisionWorkflow.php',
     'ArcanistCloseWorkflow' => 'workflow/ArcanistCloseWorkflow.php',
     'ArcanistClosureLinter' => 'lint/linter/ArcanistClosureLinter.php',
     'ArcanistClosureLinterTestCase' => 'lint/linter/__tests__/ArcanistClosureLinterTestCase.php',
     'ArcanistCoffeeLintLinter' => 'lint/linter/ArcanistCoffeeLintLinter.php',
     'ArcanistCoffeeLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCoffeeLintLinterTestCase.php',
     'ArcanistCommentRemover' => 'parser/ArcanistCommentRemover.php',
     'ArcanistCommentRemoverTestCase' => 'parser/__tests__/ArcanistCommentRemoverTestCase.php',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentSpacingXHPASTLinterRule.php',
     'ArcanistCommentStyleXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentStyleXHPASTLinterRule.php',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCommentStyleXHPASTLinterRuleTestCase.php',
     'ArcanistCommitRef' => 'ref/ArcanistCommitRef.php',
     'ArcanistCommitUpstreamHardpointLoader' => 'loader/ArcanistCommitUpstreamHardpointLoader.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',
     'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
     'ArcanistConfigurationDrivenLintEngine' => 'lint/engine/ArcanistConfigurationDrivenLintEngine.php',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'unit/engine/ArcanistConfigurationDrivenUnitTestEngine.php',
     'ArcanistConfigurationManager' => 'configuration/ArcanistConfigurationManager.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',
     'ArcanistDeprecationXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeprecationXHPASTLinterRule.php',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeprecationXHPASTLinterRuleTestCase.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',
     'ArcanistDiffWorkflow' => 'workflow/ArcanistDiffWorkflow.php',
     'ArcanistDifferentialCommitMessage' => 'differential/ArcanistDifferentialCommitMessage.php',
     'ArcanistDifferentialCommitMessageParserException' => 'differential/ArcanistDifferentialCommitMessageParserException.php',
     'ArcanistDifferentialDependencyGraph' => 'differential/ArcanistDifferentialDependencyGraph.php',
     'ArcanistDifferentialRevisionHash' => 'differential/constants/ArcanistDifferentialRevisionHash.php',
     'ArcanistDifferentialRevisionStatus' => 'differential/constants/ArcanistDifferentialRevisionStatus.php',
     'ArcanistDoubleQuoteXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDoubleQuoteXHPASTLinterRule.php',
     'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDoubleQuoteXHPASTLinterRuleTestCase.php',
     'ArcanistDownloadWorkflow' => 'workflow/ArcanistDownloadWorkflow.php',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateKeysInArrayXHPASTLinterRule.php',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase.php',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateSwitchCaseXHPASTLinterRule.php',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase.php',
     'ArcanistDynamicDefineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDynamicDefineXHPASTLinterRule.php',
     'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDynamicDefineXHPASTLinterRuleTestCase.php',
     'ArcanistElseIfUsageXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistElseIfUsageXHPASTLinterRule.php',
     'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistElseIfUsageXHPASTLinterRuleTestCase.php',
     'ArcanistEmptyFileXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyFileXHPASTLinterRule.php',
     'ArcanistEmptyStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyStatementXHPASTLinterRule.php',
     'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistEmptyStatementXHPASTLinterRuleTestCase.php',
     'ArcanistEventType' => 'events/constant/ArcanistEventType.php',
     'ArcanistExitExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExitExpressionXHPASTLinterRule.php',
     'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExitExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistExportWorkflow' => 'workflow/ArcanistExportWorkflow.php',
     'ArcanistExternalLinter' => 'lint/linter/ArcanistExternalLinter.php',
     'ArcanistExternalLinterTestCase' => 'lint/linter/__tests__/ArcanistExternalLinterTestCase.php',
     'ArcanistExtractUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExtractUseXHPASTLinterRule.php',
     'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExtractUseXHPASTLinterRuleTestCase.php',
     'ArcanistFeatureWorkflow' => 'workflow/ArcanistFeatureWorkflow.php',
     'ArcanistFileDataRef' => 'upload/ArcanistFileDataRef.php',
     'ArcanistFileUploader' => 'upload/ArcanistFileUploader.php',
     'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
     'ArcanistFilenameLinterTestCase' => 'lint/linter/__tests__/ArcanistFilenameLinterTestCase.php',
     'ArcanistFlagWorkflow' => 'workflow/ArcanistFlagWorkflow.php',
     'ArcanistFlake8Linter' => 'lint/linter/ArcanistFlake8Linter.php',
     'ArcanistFlake8LinterTestCase' => 'lint/linter/__tests__/ArcanistFlake8LinterTestCase.php',
     'ArcanistFormattedStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFormattedStringXHPASTLinterRule.php',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFormattedStringXHPASTLinterRuleTestCase.php',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule.php',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase.php',
     'ArcanistFutureLinter' => 'lint/linter/ArcanistFutureLinter.php',
     'ArcanistGeneratedLinter' => 'lint/linter/ArcanistGeneratedLinter.php',
     'ArcanistGeneratedLinterTestCase' => 'lint/linter/__tests__/ArcanistGeneratedLinterTestCase.php',
     'ArcanistGetConfigWorkflow' => 'workflow/ArcanistGetConfigWorkflow.php',
     'ArcanistGitAPI' => 'repository/api/ArcanistGitAPI.php',
     'ArcanistGitCommitMessageHardpointLoader' => 'loader/ArcanistGitCommitMessageHardpointLoader.php',
     'ArcanistGitHardpointLoader' => 'loader/ArcanistGitHardpointLoader.php',
     'ArcanistGitLandEngine' => 'land/ArcanistGitLandEngine.php',
     'ArcanistGitRevisionHardpointLoader' => 'loader/ArcanistGitRevisionHardpointLoader.php',
     'ArcanistGitUpstreamPath' => 'repository/api/ArcanistGitUpstreamPath.php',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistGlobalVariableXHPASTLinterRule.php',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistGlobalVariableXHPASTLinterRuleTestCase.php',
     'ArcanistGoLintLinter' => 'lint/linter/ArcanistGoLintLinter.php',
     'ArcanistGoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistGoLintLinterTestCase.php',
     'ArcanistGoTestResultParser' => 'unit/parser/ArcanistGoTestResultParser.php',
     'ArcanistGoTestResultParserTestCase' => 'unit/parser/__tests__/ArcanistGoTestResultParserTestCase.php',
     'ArcanistHLintLinter' => 'lint/linter/ArcanistHLintLinter.php',
     'ArcanistHLintLinterTestCase' => 'lint/linter/__tests__/ArcanistHLintLinterTestCase.php',
     'ArcanistHardpointLoader' => 'loader/ArcanistHardpointLoader.php',
     'ArcanistHelpWorkflow' => 'workflow/ArcanistHelpWorkflow.php',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule.php',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase.php',
     'ArcanistHgClientChannel' => 'hgdaemon/ArcanistHgClientChannel.php',
     'ArcanistHgProxyClient' => 'hgdaemon/ArcanistHgProxyClient.php',
     'ArcanistHgProxyServer' => 'hgdaemon/ArcanistHgProxyServer.php',
     'ArcanistHgServerChannel' => 'hgdaemon/ArcanistHgServerChannel.php',
     'ArcanistImplicitConstructorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitConstructorXHPASTLinterRule.php',
     'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitConstructorXHPASTLinterRuleTestCase.php',
     'ArcanistImplicitFallthroughXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitFallthroughXHPASTLinterRule.php',
     'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitFallthroughXHPASTLinterRuleTestCase.php',
     'ArcanistImplicitVisibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitVisibilityXHPASTLinterRule.php',
     'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitVisibilityXHPASTLinterRuleTestCase.php',
     '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',
     'ArcanistInstallCertificateWorkflow' => 'workflow/ArcanistInstallCertificateWorkflow.php',
     'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInstanceOfOperatorXHPASTLinterRule.php',
     'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInstanceofOperatorXHPASTLinterRuleTestCase.php',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceAbstractMethodXHPASTLinterRule.php',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase.php',
     'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceMethodBodyXHPASTLinterRule.php',
     'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidDefaultParameterXHPASTLinterRule.php',
     'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidModifiersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidModifiersXHPASTLinterRule.php',
     'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidModifiersXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidOctalNumericScalarXHPASTLinterRule.php',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase.php',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistIsAShouldBeInstanceOfXHPASTLinterRule.php',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase.php',
     'ArcanistJSHintLinter' => 'lint/linter/ArcanistJSHintLinter.php',
     'ArcanistJSHintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSHintLinterTestCase.php',
     'ArcanistJSONLintLinter' => 'lint/linter/ArcanistJSONLintLinter.php',
-    'ArcanistJSONLintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLintLinterTestCase.php',
     'ArcanistJSONLintRenderer' => 'lint/renderer/ArcanistJSONLintRenderer.php',
     'ArcanistJSONLinter' => 'lint/linter/ArcanistJSONLinter.php',
     'ArcanistJSONLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLinterTestCase.php',
     'ArcanistJscsLinter' => 'lint/linter/ArcanistJscsLinter.php',
     'ArcanistJscsLinterTestCase' => 'lint/linter/__tests__/ArcanistJscsLinterTestCase.php',
     'ArcanistKeywordCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistKeywordCasingXHPASTLinterRule.php',
     'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistKeywordCasingXHPASTLinterRuleTestCase.php',
     'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLambdaFuncFunctionXHPASTLinterRule.php',
     'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistLandEngine' => 'land/ArcanistLandEngine.php',
     'ArcanistLandWorkflow' => 'workflow/ArcanistLandWorkflow.php',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLanguageConstructParenthesesXHPASTLinterRule.php',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistLesscLinter' => 'lint/linter/ArcanistLesscLinter.php',
     'ArcanistLesscLinterTestCase' => 'lint/linter/__tests__/ArcanistLesscLinterTestCase.php',
     'ArcanistLiberateWorkflow' => 'workflow/ArcanistLiberateWorkflow.php',
     'ArcanistLibraryTestCase' => '__tests__/ArcanistLibraryTestCase.php',
     'ArcanistLintEngine' => 'lint/engine/ArcanistLintEngine.php',
     'ArcanistLintMessage' => 'lint/ArcanistLintMessage.php',
     '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',
     'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLogicalOperatorsXHPASTLinterRule.php',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLogicalOperatorsXHPASTLinterRuleTestCase.php',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLowercaseFunctionsXHPASTLinterRule.php',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase.php',
     'ArcanistMercurialAPI' => 'repository/api/ArcanistMercurialAPI.php',
     'ArcanistMercurialBranchCommitHardpointLoader' => 'loader/ArcanistMercurialBranchCommitHardpointLoader.php',
     'ArcanistMercurialHardpointLoader' => 'loader/ArcanistMercurialHardpointLoader.php',
     'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
     'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
     'ArcanistMercurialWorkingCopyCommitHardpointLoader' => 'loader/ArcanistMercurialWorkingCopyCommitHardpointLoader.php',
     'ArcanistMergeConflictLinter' => 'lint/linter/ArcanistMergeConflictLinter.php',
     'ArcanistMergeConflictLinterTestCase' => 'lint/linter/__tests__/ArcanistMergeConflictLinterTestCase.php',
     'ArcanistMessageRevisionHardpointLoader' => 'loader/ArcanistMessageRevisionHardpointLoader.php',
     'ArcanistMissingLinterException' => 'lint/linter/exception/ArcanistMissingLinterException.php',
     'ArcanistModifierOrderingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistModifierOrderingXHPASTLinterRule.php',
     'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistModifierOrderingXHPASTLinterRuleTestCase.php',
     'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamespaceFirstStatementXHPASTLinterRule.php',
     'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase.php',
     'ArcanistNamingConventionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamingConventionsXHPASTLinterRule.php',
     'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamingConventionsXHPASTLinterRuleTestCase.php',
     'ArcanistNestedNamespacesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNestedNamespacesXHPASTLinterRule.php',
     'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNestedNamespacesXHPASTLinterRuleTestCase.php',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNewlineAfterOpenTagXHPASTLinterRule.php',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase.php',
     'ArcanistNoEffectException' => 'exception/usage/ArcanistNoEffectException.php',
     'ArcanistNoEngineException' => 'exception/usage/ArcanistNoEngineException.php',
     'ArcanistNoLintLinter' => 'lint/linter/ArcanistNoLintLinter.php',
     'ArcanistNoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistNoLintLinterTestCase.php',
     'ArcanistNoParentScopeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNoParentScopeXHPASTLinterRule.php',
     'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNoParentScopeXHPASTLinterRuleTestCase.php',
     'ArcanistNoneLintRenderer' => 'lint/renderer/ArcanistNoneLintRenderer.php',
     'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistObjectOperatorSpacingXHPASTLinterRule.php',
     'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistPEP8Linter' => 'lint/linter/ArcanistPEP8Linter.php',
     'ArcanistPEP8LinterTestCase' => 'lint/linter/__tests__/ArcanistPEP8LinterTestCase.php',
     'ArcanistPHPCloseTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCloseTagXHPASTLinterRule.php',
     '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',
     'ArcanistPasteWorkflow' => 'workflow/ArcanistPasteWorkflow.php',
     'ArcanistPatchWorkflow' => 'workflow/ArcanistPatchWorkflow.php',
     'ArcanistPhpLinter' => 'lint/linter/ArcanistPhpLinter.php',
     'ArcanistPhpLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpLinterTestCase.php',
     'ArcanistPhpcsLinter' => 'lint/linter/ArcanistPhpcsLinter.php',
     'ArcanistPhpcsLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpcsLinterTestCase.php',
     'ArcanistPhpunitTestResultParser' => 'unit/parser/ArcanistPhpunitTestResultParser.php',
     'ArcanistPhrequentWorkflow' => 'workflow/ArcanistPhrequentWorkflow.php',
     'ArcanistPhutilLibraryLinter' => 'lint/linter/ArcanistPhutilLibraryLinter.php',
     'ArcanistPhutilXHPASTLinterStandard' => 'lint/linter/standards/phutil/ArcanistPhutilXHPASTLinterStandard.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPlusOperatorOnStringsXHPASTLinterRule.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase.php',
     'ArcanistPregQuoteMisuseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPregQuoteMisuseXHPASTLinterRule.php',
     'ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase.php',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPublicPropertyXHPASTLinterRule.php',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPublicPropertyXHPASTLinterRuleTestCase.php',
     'ArcanistPuppetLintLinter' => 'lint/linter/ArcanistPuppetLintLinter.php',
     'ArcanistPuppetLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPuppetLintLinterTestCase.php',
     'ArcanistPyFlakesLinter' => 'lint/linter/ArcanistPyFlakesLinter.php',
     'ArcanistPyFlakesLinterTestCase' => 'lint/linter/__tests__/ArcanistPyFlakesLinterTestCase.php',
     'ArcanistPyLintLinter' => 'lint/linter/ArcanistPyLintLinter.php',
     'ArcanistPyLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPyLintLinterTestCase.php',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistRaggedClassTreeEdgeXHPASTLinterRule.php',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase.php',
     'ArcanistRef' => 'ref/ArcanistRef.php',
     'ArcanistRefQuery' => 'ref/ArcanistRefQuery.php',
     'ArcanistRepositoryAPI' => 'repository/api/ArcanistRepositoryAPI.php',
     'ArcanistRepositoryAPIMiscTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIMiscTestCase.php',
     'ArcanistRepositoryAPIStateTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php',
     'ArcanistRepositoryRef' => 'ref/ArcanistRepositoryRef.php',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedAsIteratorXHPASTLinterRule.php',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedAsIteratorXHPASTLinterRuleTestCase.php',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorReferenceXHPASTLinterRule.php',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorXHPASTLinterRule.php',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorXHPASTLinterRuleTestCase.php',
     'ArcanistRevertWorkflow' => 'workflow/ArcanistRevertWorkflow.php',
     'ArcanistRevisionRef' => 'ref/ArcanistRevisionRef.php',
     'ArcanistRevisionRefSource' => 'ref/ArcanistRevisionRefSource.php',
     'ArcanistRuboCopLinter' => 'lint/linter/ArcanistRuboCopLinter.php',
     'ArcanistRuboCopLinterTestCase' => 'lint/linter/__tests__/ArcanistRuboCopLinterTestCase.php',
     'ArcanistRubyLinter' => 'lint/linter/ArcanistRubyLinter.php',
     'ArcanistRubyLinterTestCase' => 'lint/linter/__tests__/ArcanistRubyLinterTestCase.php',
     'ArcanistScriptAndRegexLinter' => 'lint/linter/ArcanistScriptAndRegexLinter.php',
     'ArcanistSelfClassReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfClassReferenceXHPASTLinterRule.php',
     'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfClassReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfMemberReferenceXHPASTLinterRule.php',
     'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistSemicolonSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSemicolonSpacingXHPASTLinterRule.php',
     'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSemicolonSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistSetConfigWorkflow' => 'workflow/ArcanistSetConfigWorkflow.php',
     'ArcanistSetting' => 'configuration/ArcanistSetting.php',
     'ArcanistSettings' => 'configuration/ArcanistSettings.php',
     'ArcanistShellCompleteWorkflow' => 'workflow/ArcanistShellCompleteWorkflow.php',
     'ArcanistSingleLintEngine' => 'lint/engine/ArcanistSingleLintEngine.php',
     'ArcanistSlownessXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSlownessXHPASTLinterRule.php',
     'ArcanistSlownessXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSlownessXHPASTLinterRuleTestCase.php',
     'ArcanistSpellingLinter' => 'lint/linter/ArcanistSpellingLinter.php',
     'ArcanistSpellingLinterTestCase' => 'lint/linter/__tests__/ArcanistSpellingLinterTestCase.php',
     'ArcanistStartWorkflow' => 'workflow/ArcanistStartWorkflow.php',
     'ArcanistStaticThisXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistStaticThisXHPASTLinterRule.php',
     'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistStaticThisXHPASTLinterRuleTestCase.php',
     'ArcanistStopWorkflow' => 'workflow/ArcanistStopWorkflow.php',
     'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
     'ArcanistSummaryLintRenderer' => 'lint/renderer/ArcanistSummaryLintRenderer.php',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSyntaxErrorXHPASTLinterRule.php',
     'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTautologicalExpressionXHPASTLinterRule.php',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTautologicalExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistTestResultParser' => 'unit/parser/ArcanistTestResultParser.php',
     'ArcanistTestXHPASTLintSwitchHook' => 'lint/linter/__tests__/ArcanistTestXHPASTLintSwitchHook.php',
     'ArcanistTextLinter' => 'lint/linter/ArcanistTextLinter.php',
     'ArcanistTextLinterTestCase' => 'lint/linter/__tests__/ArcanistTextLinterTestCase.php',
     'ArcanistThisReassignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistThisReassignmentXHPASTLinterRule.php',
     'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistThisReassignmentXHPASTLinterRuleTestCase.php',
     'ArcanistTimeWorkflow' => 'workflow/ArcanistTimeWorkflow.php',
     'ArcanistToStringExceptionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistToStringExceptionXHPASTLinterRule.php',
     'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistToStringExceptionXHPASTLinterRuleTestCase.php',
     'ArcanistTodoCommentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTodoCommentXHPASTLinterRule.php',
     'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTodoCommentXHPASTLinterRuleTestCase.php',
     'ArcanistTodoWorkflow' => 'workflow/ArcanistTodoWorkflow.php',
     'ArcanistUSEnglishTranslation' => 'internationalization/ArcanistUSEnglishTranslation.php',
     'ArcanistUnableToParseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnableToParseXHPASTLinterRule.php',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule.php',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule.php',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistUndeclaredVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUndeclaredVariableXHPASTLinterRule.php',
     'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUndeclaredVariableXHPASTLinterRuleTestCase.php',
     'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnexpectedReturnValueXHPASTLinterRule.php',
     'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase.php',
     'ArcanistUnitConsoleRenderer' => 'unit/renderer/ArcanistUnitConsoleRenderer.php',
     'ArcanistUnitRenderer' => 'unit/renderer/ArcanistUnitRenderer.php',
     'ArcanistUnitTestEngine' => 'unit/engine/ArcanistUnitTestEngine.php',
     'ArcanistUnitTestResult' => 'unit/ArcanistUnitTestResult.php',
     'ArcanistUnitTestResultTestCase' => 'unit/__tests__/ArcanistUnitTestResultTestCase.php',
     'ArcanistUnitTestableLintEngine' => 'lint/engine/ArcanistUnitTestableLintEngine.php',
     'ArcanistUnitWorkflow' => 'workflow/ArcanistUnitWorkflow.php',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessaryFinalModifierXHPASTLinterRule.php',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase.php',
     'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySemicolonXHPASTLinterRule.php',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySymbolAliasXHPASTLinterRule.php',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase.php',
     'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnsafeDynamicStringXHPASTLinterRule.php',
     'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase.php',
     'ArcanistUpgradeWorkflow' => 'workflow/ArcanistUpgradeWorkflow.php',
     'ArcanistUploadWorkflow' => 'workflow/ArcanistUploadWorkflow.php',
     'ArcanistUsageException' => 'exception/ArcanistUsageException.php',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUseStatementNamespacePrefixXHPASTLinterRule.php',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase.php',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUselessOverridingMethodXHPASTLinterRule.php',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase.php',
     'ArcanistUserAbortException' => 'exception/usage/ArcanistUserAbortException.php',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableReferenceSpacingXHPASTLinterRule.php',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistVariableVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableVariableXHPASTLinterRule.php',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableVariableXHPASTLinterRuleTestCase.php',
     'ArcanistVersionWorkflow' => 'workflow/ArcanistVersionWorkflow.php',
     'ArcanistWeldWorkflow' => 'workflow/ArcanistWeldWorkflow.php',
     'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
     'ArcanistWorkflow' => 'workflow/ArcanistWorkflow.php',
     'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.php',
     'ArcanistWorkingCopyStateRef' => 'ref/ArcanistWorkingCopyStateRef.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',
     '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',
     'FutureIterator' => 'future/FutureIterator.php',
     'FutureIteratorTestCase' => 'future/__tests__/FutureIteratorTestCase.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',
     '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',
     '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',
     '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',
     'PhutilFileTree' => 'filesystem/PhutilFileTree.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_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_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_natural_list' => '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',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAliasWorkflow' => 'ArcanistWorkflow',
     'ArcanistAmendWorkflow' => 'ArcanistWorkflow',
     'ArcanistAnoidWorkflow' => 'ArcanistWorkflow',
     'ArcanistArrayCombineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArraySeparatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArrayValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBackoutWorkflow' => 'ArcanistWorkflow',
     'ArcanistBaseCommitParser' => 'Phobject',
     'ArcanistBaseCommitParserTestCase' => 'PhutilTestCase',
     'ArcanistBaseXHPASTLinter' => 'ArcanistFutureLinter',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBlindlyTrustHTTPEngineExtension' => 'PhutilHTTPEngineExtension',
     'ArcanistBookmarkWorkflow' => 'ArcanistFeatureWorkflow',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBranchRef' => 'ArcanistRef',
     'ArcanistBranchWorkflow' => 'ArcanistFeatureWorkflow',
     'ArcanistBrowseCommitHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistBrowseCommitURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
     'ArcanistBrowseObjectNameURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
     'ArcanistBrowsePathURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
     'ArcanistBrowseRef' => 'ArcanistRef',
     'ArcanistBrowseRevisionURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
     'ArcanistBrowseURIHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistBrowseURIRef' => 'ArcanistRef',
     'ArcanistBrowseWorkflow' => 'ArcanistWorkflow',
     'ArcanistBuildPlanRef' => 'Phobject',
     'ArcanistBuildRef' => 'Phobject',
     'ArcanistBundle' => 'Phobject',
     'ArcanistBundleTestCase' => 'PhutilTestCase',
     'ArcanistCSSLintLinter' => 'ArcanistExternalLinter',
     'ArcanistCSSLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCSharpLinter' => 'ArcanistLinter',
     'ArcanistCallConduitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCallParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCapabilityNotSupportedException' => 'Exception',
     'ArcanistCastSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCheckstyleXMLLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistChmodLinter' => 'ArcanistLinter',
     'ArcanistChmodLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistClassExtendsObjectXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistClassNameLiteralXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCloseRevisionWorkflow' => 'ArcanistWorkflow',
     'ArcanistCloseWorkflow' => 'ArcanistWorkflow',
     'ArcanistClosureLinter' => 'ArcanistExternalLinter',
     'ArcanistClosureLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCoffeeLintLinter' => 'ArcanistExternalLinter',
     'ArcanistCoffeeLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCommentRemover' => 'Phobject',
     'ArcanistCommentRemoverTestCase' => 'PhutilTestCase',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCommitRef' => 'ArcanistRef',
     'ArcanistCommitUpstreamHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistComposerLinter' => 'ArcanistLinter',
     'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistConduitCall' => 'Phobject',
     'ArcanistConduitEngine' => 'Phobject',
     'ArcanistConfiguration' => 'Phobject',
     'ArcanistConfigurationDrivenLintEngine' => 'ArcanistLintEngine',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'ArcanistUnitTestEngine',
     'ArcanistConfigurationManager' => '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',
     'ArcanistDeprecationXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDiffByteSizeException' => 'Exception',
     'ArcanistDiffChange' => 'Phobject',
     'ArcanistDiffChangeType' => 'Phobject',
     'ArcanistDiffHunk' => 'Phobject',
     'ArcanistDiffParser' => 'Phobject',
     'ArcanistDiffParserTestCase' => 'PhutilTestCase',
     'ArcanistDiffUtils' => 'Phobject',
     'ArcanistDiffUtilsTestCase' => 'PhutilTestCase',
     'ArcanistDiffWorkflow' => 'ArcanistWorkflow',
     'ArcanistDifferentialCommitMessage' => 'Phobject',
     'ArcanistDifferentialCommitMessageParserException' => 'Exception',
     'ArcanistDifferentialDependencyGraph' => 'AbstractDirectedGraph',
     'ArcanistDifferentialRevisionHash' => 'Phobject',
     'ArcanistDifferentialRevisionStatus' => 'Phobject',
     'ArcanistDoubleQuoteXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDownloadWorkflow' => 'ArcanistWorkflow',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDynamicDefineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistElseIfUsageXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEmptyFileXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEmptyStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEventType' => 'PhutilEventType',
     'ArcanistExitExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistExportWorkflow' => 'ArcanistWorkflow',
     'ArcanistExternalLinter' => 'ArcanistFutureLinter',
     'ArcanistExternalLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistExtractUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFeatureWorkflow' => 'ArcanistWorkflow',
     'ArcanistFileDataRef' => 'Phobject',
     'ArcanistFileUploader' => 'Phobject',
     'ArcanistFilenameLinter' => 'ArcanistLinter',
     'ArcanistFilenameLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistFlagWorkflow' => 'ArcanistWorkflow',
     'ArcanistFlake8Linter' => 'ArcanistExternalLinter',
     'ArcanistFlake8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistFormattedStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFutureLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistGetConfigWorkflow' => 'ArcanistWorkflow',
     'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
     'ArcanistGitCommitMessageHardpointLoader' => 'ArcanistGitHardpointLoader',
     'ArcanistGitHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistGitLandEngine' => 'ArcanistLandEngine',
     'ArcanistGitRevisionHardpointLoader' => 'ArcanistGitHardpointLoader',
     'ArcanistGitUpstreamPath' => 'Phobject',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
     'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
     'ArcanistHLintLinter' => 'ArcanistExternalLinter',
     'ArcanistHLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistHardpointLoader' => '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',
     'ArcanistInstallCertificateWorkflow' => 'ArcanistWorkflow',
     'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidModifiersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistJSHintLinter' => 'ArcanistExternalLinter',
     'ArcanistJSHintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistJSONLintLinter' => 'ArcanistExternalLinter',
-    'ArcanistJSONLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistJSONLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistJSONLinter' => 'ArcanistLinter',
     'ArcanistJSONLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistJscsLinter' => 'ArcanistExternalLinter',
     'ArcanistJscsLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistKeywordCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLandEngine' => 'Phobject',
     'ArcanistLandWorkflow' => 'ArcanistWorkflow',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLesscLinter' => 'ArcanistExternalLinter',
     'ArcanistLesscLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistLiberateWorkflow' => 'ArcanistWorkflow',
     'ArcanistLibraryTestCase' => 'PhutilLibraryTestCase',
     'ArcanistLintEngine' => 'Phobject',
     'ArcanistLintMessage' => 'Phobject',
     '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',
     'ArcanistListWorkflow' => 'ArcanistWorkflow',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
     'ArcanistMercurialBranchCommitHardpointLoader' => 'ArcanistMercurialHardpointLoader',
     'ArcanistMercurialHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistMercurialParser' => 'Phobject',
     'ArcanistMercurialParserTestCase' => 'PhutilTestCase',
     'ArcanistMercurialWorkingCopyCommitHardpointLoader' => 'ArcanistMercurialHardpointLoader',
     'ArcanistMergeConflictLinter' => 'ArcanistLinter',
     'ArcanistMergeConflictLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistMessageRevisionHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistMissingLinterException' => 'Exception',
     'ArcanistModifierOrderingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNamingConventionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNestedNamespacesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNoEffectException' => 'ArcanistUsageException',
     'ArcanistNoEngineException' => 'ArcanistUsageException',
     'ArcanistNoLintLinter' => 'ArcanistLinter',
     'ArcanistNoLintLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistNoParentScopeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNoneLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPEP8Linter' => 'ArcanistExternalLinter',
     'ArcanistPEP8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPHPCloseTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     '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',
     'ArcanistPasteWorkflow' => 'ArcanistWorkflow',
     'ArcanistPatchWorkflow' => 'ArcanistWorkflow',
     'ArcanistPhpLinter' => 'ArcanistExternalLinter',
     'ArcanistPhpLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPhpcsLinter' => 'ArcanistExternalLinter',
     'ArcanistPhpcsLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPhpunitTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistPhrequentWorkflow' => 'ArcanistWorkflow',
     'ArcanistPhutilLibraryLinter' => 'ArcanistLinter',
     'ArcanistPhutilXHPASTLinterStandard' => 'ArcanistLinterStandard',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPregQuoteMisuseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPuppetLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPuppetLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyFlakesLinter' => 'ArcanistExternalLinter',
     'ArcanistPyFlakesLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPyLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRef' => 'Phobject',
     'ArcanistRefQuery' => 'Phobject',
     'ArcanistRepositoryAPI' => 'Phobject',
     'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryRef' => 'ArcanistRef',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRevertWorkflow' => 'ArcanistWorkflow',
     'ArcanistRevisionRef' => 'ArcanistRef',
     'ArcanistRevisionRefSource' => 'Phobject',
     'ArcanistRuboCopLinter' => 'ArcanistExternalLinter',
     'ArcanistRuboCopLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRubyLinter' => 'ArcanistExternalLinter',
     'ArcanistRubyLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistScriptAndRegexLinter' => 'ArcanistLinter',
     'ArcanistSelfClassReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSemicolonSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSetConfigWorkflow' => 'ArcanistWorkflow',
     'ArcanistSetting' => 'Phobject',
     'ArcanistSettings' => 'Phobject',
     'ArcanistShellCompleteWorkflow' => 'ArcanistWorkflow',
     'ArcanistSingleLintEngine' => 'ArcanistLintEngine',
     'ArcanistSlownessXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSlownessXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSpellingLinter' => 'ArcanistLinter',
     'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistStartWorkflow' => 'ArcanistPhrequentWorkflow',
     'ArcanistStaticThisXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistStopWorkflow' => 'ArcanistPhrequentWorkflow',
     'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
     'ArcanistSummaryLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTasksWorkflow' => 'ArcanistWorkflow',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTestResultParser' => 'Phobject',
     'ArcanistTestXHPASTLintSwitchHook' => 'ArcanistXHPASTLintSwitchHook',
     'ArcanistTextLinter' => 'ArcanistLinter',
     'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistThisReassignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTimeWorkflow' => 'ArcanistPhrequentWorkflow',
     'ArcanistToStringExceptionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTodoCommentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTodoWorkflow' => 'ArcanistWorkflow',
     'ArcanistUSEnglishTranslation' => 'PhutilTranslation',
     'ArcanistUnableToParseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUndeclaredVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnitConsoleRenderer' => 'ArcanistUnitRenderer',
     'ArcanistUnitRenderer' => 'Phobject',
     'ArcanistUnitTestEngine' => 'Phobject',
     'ArcanistUnitTestResult' => 'Phobject',
     'ArcanistUnitTestResultTestCase' => 'PhutilTestCase',
     'ArcanistUnitTestableLintEngine' => 'ArcanistLintEngine',
     'ArcanistUnitWorkflow' => 'ArcanistWorkflow',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUpgradeWorkflow' => 'ArcanistWorkflow',
     'ArcanistUploadWorkflow' => 'ArcanistWorkflow',
     'ArcanistUsageException' => 'Exception',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUserAbortException' => 'ArcanistUsageException',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVariableVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVersionWorkflow' => 'ArcanistWorkflow',
     'ArcanistWeldWorkflow' => 'ArcanistWorkflow',
     'ArcanistWhichWorkflow' => 'ArcanistWorkflow',
     'ArcanistWorkflow' => 'Phobject',
     'ArcanistWorkingCopyIdentity' => 'Phobject',
     'ArcanistWorkingCopyStateRef' => 'ArcanistRef',
     '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',
     'ExecFuture' => 'PhutilExecutableFuture',
     'ExecFutureTestCase' => 'PhutilTestCase',
     'ExecPassthruTestCase' => 'PhutilTestCase',
     'FileFinder' => 'Phobject',
     'FileFinderTestCase' => 'PhutilTestCase',
     'FileList' => 'Phobject',
     'Filesystem' => 'Phobject',
     'FilesystemException' => 'Exception',
     'FilesystemTestCase' => 'PhutilTestCase',
     'Future' => 'Phobject',
     'FutureIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'FutureIteratorTestCase' => 'PhutilTestCase',
     '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',
     'PhageExecuteAction' => 'PhageAction',
     'PhageLocalAction' => 'PhageAgentAction',
     'PhagePHPAgent' => 'Phobject',
     'PhagePHPAgentBootloader' => 'PhageAgentBootloader',
     'PhagePlanAction' => 'PhageAction',
     'PhageWorkflow' => 'PhutilArgumentWorkflow',
     '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',
     ),
     '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',
     'PhutilFileTree' => 'Phobject',
     '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/channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php b/src/channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php
index c9373918..29999d53 100644
--- a/src/channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php
+++ b/src/channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php
@@ -1,66 +1,67 @@
 <?php
 
 final class PhutilPHPObjectProtocolChannelTestCase extends PhutilTestCase {
 
   public function testPHPObjectChannelBasics() {
     list($x, $y) = PhutilSocketChannel::newChannelPair();
     $xp = new PhutilPHPObjectProtocolChannel($x);
     $yp = new PhutilPHPObjectProtocolChannel($y);
 
     $object = (object)array(
       'key' => mt_rand(),
     );
 
     $xp->write($object);
     $xp->flush();
     $result = $yp->waitForMessage();
 
     $this->assertTrue(
       (array)$object === (array)$result,
       pht('Values are identical.'));
 
     $this->assertFalse(
       $object === $result,
       pht('Objects are not the same.'));
   }
 
   public function testCloseSocketWriteChannel() {
     list($x, $y) = PhutilSocketChannel::newChannelPair();
     $xp = new PhutilPHPObjectProtocolChannel($x);
     $yp = new PhutilPHPObjectProtocolChannel($y);
 
     $yp->closeWriteChannel();
     $yp->update();
 
     // NOTE: This test is more broad than the implementation needs to be. A
     // better test would be to verify that this throws an exception:
     //
     //   $xp->waitForMessage();
     //
     // However, if the test breaks, that method will hang forever instead of
     // returning, which would be hard to diagnose. Since the current
     // implementation shuts down the entire channel, just test for that.
 
     $this->assertFalse($xp->update(), pht('Expected channel to close.'));
   }
 
   public function testCloseExecWriteChannel() {
-    $future = new ExecFuture('cat');
+    $bin = $this->getSupportExecutable('cat');
+    $future = new ExecFuture('php -f %R', $bin);
 
     // If this test breaks, we want to explode, not hang forever.
     $future->setTimeout(5);
 
     $exec_channel = new PhutilExecChannel($future);
     $exec_channel->write('quack');
     $exec_channel->closeWriteChannel();
 
     // If `closeWriteChannel()` did what it is supposed to, this will just
     // echo "quack" and exit with no error code. If the channel did not close,
     // this will time out after 5 seconds and throw.
     $future->resolvex();
 
     $this->assertTrue(true);
   }
 
 
 }
diff --git a/src/error/__tests__/PhutilOpaqueEnvelopeTestCase.php b/src/error/__tests__/PhutilOpaqueEnvelopeTestCase.php
index 2f6c06b2..ba416ce6 100644
--- a/src/error/__tests__/PhutilOpaqueEnvelopeTestCase.php
+++ b/src/error/__tests__/PhutilOpaqueEnvelopeTestCase.php
@@ -1,47 +1,62 @@
 <?php
 
 final class PhutilOpaqueEnvelopeTestCase extends PhutilTestCase {
 
   public function testOpaqueEnvelope() {
 
     // NOTE: When run via "arc diff", this test's trace may include portions of
     // the diff itself, and thus this source code. Since we look for the secret
     // in traces later on, split it apart here so that invocation via
     // "arc diff" doesn't create a false test failure.
-
     $secret = 'hunter'.'2';
 
+    // Also split apart this "signpost" value which we are not going to put in
+    // an envelope. We expect to be able to find it in the argument lists in
+    // stack traces, and don't want a false positive.
+    $signpost = 'shaman'.'3';
+
     $envelope = new PhutilOpaqueEnvelope($secret);
 
     $this->assertFalse(strpos(var_export($envelope, true), $secret));
 
     $this->assertFalse(strpos(print_r($envelope, true), $secret));
 
     ob_start();
     var_dump($envelope);
     $dump = ob_get_clean();
 
     $this->assertFalse(strpos($dump, $secret));
 
     try {
-      $this->throwTrace($envelope);
+      $this->throwTrace($envelope, $signpost);
     } catch (Exception $ex) {
       $trace = $ex->getTrace();
-      $this->assertFalse(strpos(print_r($trace, true), $secret));
+
+      // NOTE: The entire trace may be very large and contain complex
+      // recursive datastructures. Look at only the last few frames: we expect
+      // to see the signpost value but not the secret.
+      $trace = array_slice($trace, 0, 2);
+      $trace = print_r($trace, true);
+
+      $this->assertTrue(strpos($trace, $signpost) !== false);
+      $this->assertFalse(strpos($trace, $secret));
     }
 
-    $backtrace = $this->getBacktrace($envelope);
+    $backtrace = $this->getBacktrace($envelope, $signpost);
+    $backtrace = array_slice($backtrace, 0, 2);
+
+    $this->assertTrue(strpos($trace, $signpost) !== false);
     $this->assertFalse(strpos(print_r($backtrace, true), $secret));
 
     $this->assertEqual($secret, $envelope->openEnvelope());
   }
 
-  private function throwTrace($v) {
+  private function throwTrace($v, $w) {
     throw new Exception('!');
   }
 
-  private function getBacktrace($v) {
+  private function getBacktrace($v, $w) {
     return debug_backtrace();
   }
 
 }
diff --git a/src/filesystem/Filesystem.php b/src/filesystem/Filesystem.php
index a88ed12a..475ae0c1 100644
--- a/src/filesystem/Filesystem.php
+++ b/src/filesystem/Filesystem.php
@@ -1,1248 +1,1274 @@
 <?php
 
 /**
  * Simple wrapper class for common filesystem tasks like reading and writing
  * files. When things go wrong, this class throws detailed exceptions with
  * good information about what didn't work.
  *
  * Filesystem will resolve relative paths against PWD from the environment.
  * When Filesystem is unable to complete an operation, it throws a
  * FilesystemException.
  *
  * @task directory   Directories
  * @task file        Files
  * @task path        Paths
  * @task exec        Executables
  * @task assert      Assertions
  */
 final class Filesystem extends Phobject {
 
 
 /* -(  Files  )-------------------------------------------------------------- */
 
 
   /**
    * Read a file in a manner similar to file_get_contents(), but throw detailed
    * exceptions on failure.
    *
    * @param  string  File path to read. This file must exist and be readable,
    *                 or an exception will be thrown.
    * @return string  Contents of the specified file.
    *
    * @task   file
    */
   public static function readFile($path) {
     $path = self::resolvePath($path);
 
     self::assertExists($path);
     self::assertIsFile($path);
     self::assertReadable($path);
 
     $data = @file_get_contents($path);
     if ($data === false) {
       throw new FilesystemException(
         $path,
         pht("Failed to read file '%s'.", $path));
     }
 
     return $data;
   }
 
   /**
    * Make assertions about the state of path in preparation for
    * writeFile() and writeFileIfChanged().
    */
   private static function assertWritableFile($path) {
     $path = self::resolvePath($path);
     $dir = dirname($path);
 
     self::assertExists($dir);
     self::assertIsDirectory($dir);
 
     // File either needs to not exist and have a writable parent, or be
     // writable itself.
     $exists = true;
     try {
       self::assertNotExists($path);
       $exists = false;
     } catch (Exception $ex) {
       self::assertWritable($path);
     }
 
     if (!$exists) {
       self::assertWritable($dir);
     }
   }
 
   /**
    * Write a file in a manner similar to file_put_contents(), but throw
    * detailed exceptions on failure. If the file already exists, it will be
    * overwritten.
    *
    * @param  string  File path to write. This file must be writable and its
    *                 parent directory must exist.
    * @param  string  Data to write.
    *
    * @task   file
    */
   public static function writeFile($path, $data) {
     self::assertWritableFile($path);
 
     if (@file_put_contents($path, $data) === false) {
       throw new FilesystemException(
         $path,
         pht("Failed to write file '%s'.", $path));
     }
   }
 
   /**
    * Write a file in a manner similar to `file_put_contents()`, but only touch
    * the file if the contents are different, and throw detailed exceptions on
    * failure.
    *
    * As this function is used in build steps to update code, if we write a new
    * file, we do so by writing to a temporary file and moving it into place.
    * This allows a concurrently reading process to see a consistent view of the
    * file without needing locking; any given read of the file is guaranteed to
    * be self-consistent and not see partial file contents.
    *
    * @param string file path to write
    * @param string data to write
    *
    * @return boolean indicating whether the file was changed by this function.
    */
   public static function writeFileIfChanged($path, $data) {
     if (file_exists($path)) {
       $current = self::readFile($path);
       if ($current === $data) {
         return false;
       }
     }
     self::assertWritableFile($path);
 
     // Create the temporary file alongside the intended destination,
     // as this ensures that the rename() will be atomic (on the same fs)
     $dir = dirname($path);
     $temp = tempnam($dir, 'GEN');
     if (!$temp) {
       throw new FilesystemException(
         $dir,
         pht('Unable to create temporary file in %s.', $dir));
     }
     try {
       self::writeFile($temp, $data);
       // tempnam will always restrict ownership to us, broaden
       // it so that these files respect the actual umask
       self::changePermissions($temp, 0666 & ~umask());
       // This will appear atomic to concurrent readers
       $ok = rename($temp, $path);
       if (!$ok) {
         throw new FilesystemException(
           $path,
           pht('Unable to move %s to %s.', $temp, $path));
       }
     } catch (Exception $e) {
       // Make best effort to remove temp file
       unlink($temp);
       throw $e;
     }
     return true;
   }
 
 
   /**
    * Write data to unique file, without overwriting existing files. This is
    * useful if you want to write a ".bak" file or something similar, but want
    * to make sure you don't overwrite something already on disk.
    *
    * This function will add a number to the filename if the base name already
    * exists, e.g. "example.bak", "example.bak.1", "example.bak.2", etc. (Don't
    * rely on this exact behavior, of course.)
    *
    * @param   string  Suggested filename, like "example.bak". This name will
    *                  be used if it does not exist, or some similar name will
    *                  be chosen if it does.
    * @param   string  Data to write to the file.
    * @return  string  Path to a newly created and written file which did not
    *                  previously exist, like "example.bak.3".
    * @task file
    */
   public static function writeUniqueFile($base, $data) {
     $full_path = self::resolvePath($base);
     $sequence = 0;
     assert_stringlike($data);
     // Try 'file', 'file.1', 'file.2', etc., until something doesn't exist.
 
     while (true) {
       $try_path = $full_path;
       if ($sequence) {
         $try_path .= '.'.$sequence;
       }
 
       $handle = @fopen($try_path, 'x');
       if ($handle) {
         $ok = fwrite($handle, $data);
         if ($ok === false) {
           throw new FilesystemException(
             $try_path,
             pht('Failed to write file data.'));
         }
 
         $ok = fclose($handle);
         if (!$ok) {
           throw new FilesystemException(
             $try_path,
             pht('Failed to close file handle.'));
         }
 
         return $try_path;
       }
 
       $sequence++;
     }
   }
 
 
   /**
    * Append to a file without having to deal with file handles, with
    * detailed exceptions on failure.
    *
    * @param  string  File path to write. This file must be writable or its
    *                 parent directory must exist and be writable.
    * @param  string  Data to write.
    *
    * @task   file
    */
   public static function appendFile($path, $data) {
     $path = self::resolvePath($path);
 
     // Use self::writeFile() if the file doesn't already exist
     try {
       self::assertExists($path);
     } catch (FilesystemException $ex) {
       self::writeFile($path, $data);
       return;
     }
 
     // File needs to exist or the directory needs to be writable
     $dir = dirname($path);
     self::assertExists($dir);
     self::assertIsDirectory($dir);
     self::assertWritable($dir);
     assert_stringlike($data);
 
     if (($fh = fopen($path, 'a')) === false) {
       throw new FilesystemException(
         $path,
         pht("Failed to open file '%s'.", $path));
     }
     $dlen = strlen($data);
     if (fwrite($fh, $data) !== $dlen) {
       throw new FilesystemException(
         $path,
         pht("Failed to write %d bytes to '%s'.", $dlen, $path));
     }
     if (!fflush($fh) || !fclose($fh)) {
       throw new FilesystemException(
         $path,
         pht("Failed closing file '%s' after write.", $path));
     }
   }
 
 
   /**
    * Copy a file, preserving file attributes (if relevant for the OS).
    *
    * @param string  File path to copy from.  This file must exist and be
    *                readable, or an exception will be thrown.
    * @param string  File path to copy to.  If a file exists at this path
    *                already, it wll be overwritten.
    *
    * @task  file
    */
   public static function copyFile($from, $to) {
     $from = self::resolvePath($from);
     $to   = self::resolvePath($to);
 
     self::assertExists($from);
     self::assertIsFile($from);
     self::assertReadable($from);
 
     if (phutil_is_windows()) {
       execx('copy /Y %s %s', $from, $to);
     } else {
       execx('cp -p %s %s', $from, $to);
     }
   }
 
 
   /**
    * Remove a file or directory.
    *
    * @param  string    File to a path or directory to remove.
    * @return void
    *
    * @task   file
    */
   public static function remove($path) {
     if (!strlen($path)) {
       // Avoid removing PWD.
       throw new Exception(
         pht(
           'No path provided to %s.',
           __FUNCTION__.'()'));
     }
 
     $path = self::resolvePath($path);
 
     if (!file_exists($path)) {
       return;
     }
 
     self::executeRemovePath($path);
   }
 
   /**
    * Rename a file or directory.
    *
    * @param string    Old path.
    * @param string    New path.
    *
    * @task file
    */
   public static function rename($old, $new) {
     $old = self::resolvePath($old);
     $new = self::resolvePath($new);
 
     self::assertExists($old);
 
     $ok = rename($old, $new);
     if (!$ok) {
       throw new FilesystemException(
         $new,
         pht("Failed to rename '%s' to '%s'!", $old, $new));
     }
   }
 
 
   /**
    * Internal. Recursively remove a file or an entire directory. Implements
    * the core function of @{method:remove} in a way that works on Windows.
    *
    * @param  string    File to a path or directory to remove.
    * @return void
    *
    * @task file
    */
   private static function executeRemovePath($path) {
     if (is_dir($path) && !is_link($path)) {
       foreach (self::listDirectory($path, true) as $child) {
         self::executeRemovePath($path.DIRECTORY_SEPARATOR.$child);
       }
       $ok = rmdir($path);
       if (!$ok) {
          throw new FilesystemException(
           $path,
           pht("Failed to remove directory '%s'!", $path));
       }
     } else {
       $ok = unlink($path);
       if (!$ok) {
         throw new FilesystemException(
           $path,
           pht("Failed to remove file '%s'!", $path));
       }
     }
   }
 
 
   /**
    * Change the permissions of a file or directory.
    *
    * @param  string    Path to the file or directory.
    * @param  int       Permission umask. Note that umask is in octal, so you
    *                   should specify it as, e.g., `0777', not `777'.
    * @return void
    *
    * @task   file
    */
   public static function changePermissions($path, $umask) {
     $path = self::resolvePath($path);
 
     self::assertExists($path);
 
     if (!@chmod($path, $umask)) {
       $readable_umask = sprintf('%04o', $umask);
       throw new FilesystemException(
         $path,
         pht("Failed to chmod '%s' to '%s'.", $path, $readable_umask));
     }
   }
 
 
   /**
    * Get the last modified time of a file
    *
    * @param string Path to file
    * @return int Time last modified
    *
    * @task file
    */
   public static function getModifiedTime($path) {
     $path = self::resolvePath($path);
     self::assertExists($path);
     self::assertIsFile($path);
     self::assertReadable($path);
 
     $modified_time = @filemtime($path);
 
     if ($modified_time === false) {
       throw new FilesystemException(
         $path,
         pht('Failed to read modified time for %s.', $path));
     }
 
     return $modified_time;
   }
 
 
   /**
    * Read random bytes from /dev/urandom or equivalent. See also
    * @{method:readRandomCharacters}.
    *
    * @param   int     Number of bytes to read.
    * @return  string  Random bytestring of the provided length.
    *
    * @task file
    */
   public static function readRandomBytes($number_of_bytes) {
     $number_of_bytes = (int)$number_of_bytes;
     if ($number_of_bytes < 1) {
       throw new Exception(pht('You must generate at least 1 byte of entropy.'));
     }
 
     // Under PHP 7.2.0 and newer, we have a reasonable builtin. For older
     // versions, we fall back to various sources which have a roughly similar
     // effect.
     if (function_exists('random_bytes')) {
       return random_bytes($number_of_bytes);
     }
 
     // Try to use `openssl_random_pseudo_bytes()` if it's available. This source
     // is the most widely available source, and works on Windows/Linux/OSX/etc.
 
     if (function_exists('openssl_random_pseudo_bytes')) {
       $strong = true;
       $data = openssl_random_pseudo_bytes($number_of_bytes, $strong);
 
       if (!$strong) {
         // NOTE: This indicates we're using a weak random source. This is
         // probably OK, but maybe we should be more strict here.
       }
 
       if ($data === false) {
         throw new Exception(
           pht(
             '%s failed to generate entropy!',
             'openssl_random_pseudo_bytes()'));
       }
 
       if (strlen($data) != $number_of_bytes) {
         throw new Exception(
           pht(
             '%s returned an unexpected number of bytes (got %s, expected %s)!',
             'openssl_random_pseudo_bytes()',
             new PhutilNumber(strlen($data)),
             new PhutilNumber($number_of_bytes)));
       }
 
       return $data;
     }
 
 
     // Try to use `/dev/urandom` if it's available. This is usually available
     // on non-Windows systems, but some PHP config (open_basedir) and chrooting
     // may limit our access to it.
 
     $urandom = @fopen('/dev/urandom', 'rb');
     if ($urandom) {
       $data = @fread($urandom, $number_of_bytes);
       @fclose($urandom);
       if (strlen($data) != $number_of_bytes) {
         throw new FilesystemException(
           '/dev/urandom',
           pht('Failed to read random bytes!'));
       }
       return $data;
     }
 
     // (We might be able to try to generate entropy here from a weaker source
     // if neither of the above sources panned out, see some discussion in
     // T4153.)
 
     // We've failed to find any valid entropy source. Try to fail in the most
     // useful way we can, based on the platform.
 
     if (phutil_is_windows()) {
       throw new Exception(
         pht(
           '%s requires the PHP OpenSSL extension to be installed and enabled '.
           'to access an entropy source. On Windows, this extension is usually '.
-          'installed but not enabled by default. Enable it in your "s".',
-          __METHOD__.'()',
-          'php.ini'));
+          'installed but not enabled by default. Enable it in your "php.ini".',
+          __METHOD__.'()'));
     }
 
     throw new Exception(
       pht(
         '%s requires the PHP OpenSSL extension or access to "%s". Install or '.
         'enable the OpenSSL extension, or make sure "%s" is accessible.',
         __METHOD__.'()',
         '/dev/urandom',
         '/dev/urandom'));
   }
 
 
   /**
    * Read random alphanumeric characters from /dev/urandom or equivalent. This
    * method operates like @{method:readRandomBytes} but produces alphanumeric
    * output (a-z, 0-9) so it's appropriate for use in URIs and other contexts
    * where it needs to be human readable.
    *
    * @param   int     Number of characters to read.
    * @return  string  Random character string of the provided length.
    *
    * @task file
    */
   public static function readRandomCharacters($number_of_characters) {
 
     // NOTE: To produce the character string, we generate a random byte string
     // of the same length, select the high 5 bits from each byte, and
     // map that to 32 alphanumeric characters. This could be improved (we
     // could improve entropy per character with base-62, and some entropy
     // sources might be less entropic if we discard the low bits) but for
     // reasonable cases where we have a good entropy source and are just
     // generating some kind of human-readable secret this should be more than
     // sufficient and is vastly simpler than trying to do bit fiddling.
 
     $map = array_merge(range('a', 'z'), range('2', '7'));
 
     $result = '';
     $bytes = self::readRandomBytes($number_of_characters);
     for ($ii = 0; $ii < $number_of_characters; $ii++) {
       $result .= $map[ord($bytes[$ii]) >> 3];
     }
 
     return $result;
   }
 
 
   /**
    * Generate a random integer value in a given range.
    *
    * This method uses less-entropic random sources under older versions of PHP.
    *
    * @param int Minimum value, inclusive.
    * @param int Maximum value, inclusive.
    */
   public static function readRandomInteger($min, $max) {
     if (!is_int($min)) {
       throw new Exception(pht('Minimum value must be an integer.'));
     }
 
     if (!is_int($max)) {
       throw new Exception(pht('Maximum value must be an integer.'));
     }
 
     if ($min > $max) {
       throw new Exception(
         pht(
           'Minimum ("%d") must not be greater than maximum ("%d").',
           $min,
           $max));
     }
 
     // Under PHP 7.2.0 and newer, we can just use "random_int()". This function
     // is intended to generate cryptographically usable entropy.
     if (function_exists('random_int')) {
       return random_int($min, $max);
     }
 
     // We could find a stronger source for this, but correctly converting raw
     // bytes to an integer range without biases is fairly hard and it seems
     // like we're more likely to get that wrong than suffer a PRNG prediction
     // issue by falling back to "mt_rand()".
 
     if (($max - $min) > mt_getrandmax()) {
       throw new Exception(
         pht('mt_rand() range is smaller than the requested range.'));
     }
 
     $result = mt_rand($min, $max);
     if (!is_int($result)) {
       throw new Exception(pht('Bad return value from mt_rand().'));
     }
 
     return $result;
   }
 
 
   /**
    * Identify the MIME type of a file. This returns only the MIME type (like
    * text/plain), not the encoding (like charset=utf-8).
    *
    * @param string Path to the file to examine.
    * @param string Optional default mime type to return if the file's mime
    *               type can not be identified.
    * @return string File mime type.
    *
    * @task file
    *
    * @phutil-external-symbol function mime_content_type
    * @phutil-external-symbol function finfo_open
    * @phutil-external-symbol function finfo_file
    */
   public static function getMimeType(
     $path,
     $default = 'application/octet-stream') {
 
     $path = self::resolvePath($path);
 
     self::assertExists($path);
     self::assertIsFile($path);
     self::assertReadable($path);
 
     $mime_type = null;
 
     // Fileinfo is the best approach since it doesn't rely on `file`, but
     // it isn't builtin for older versions of PHP.
 
     if (function_exists('finfo_open')) {
       $finfo = finfo_open(FILEINFO_MIME);
       if ($finfo) {
         $result = finfo_file($finfo, $path);
         if ($result !== false) {
           $mime_type = $result;
         }
       }
     }
 
     // If we failed Fileinfo, try `file`. This works well but not all systems
     // have the binary.
 
     if ($mime_type === null) {
       list($err, $stdout) = exec_manual(
         'file --brief --mime %s',
         $path);
       if (!$err) {
         $mime_type = trim($stdout);
       }
     }
 
     // If we didn't get anywhere, try the deprecated mime_content_type()
     // function.
 
     if ($mime_type === null) {
       if (function_exists('mime_content_type')) {
         $result = mime_content_type($path);
         if ($result !== false) {
           $mime_type = $result;
         }
       }
     }
 
     // If we come back with an encoding, strip it off.
     if (strpos($mime_type, ';') !== false) {
       list($type, $encoding) = explode(';', $mime_type, 2);
       $mime_type = $type;
     }
 
     if ($mime_type === null) {
       $mime_type = $default;
     }
 
     return $mime_type;
   }
 
 
 /* -(  Directories  )-------------------------------------------------------- */
 
 
   /**
    * Create a directory in a manner similar to mkdir(), but throw detailed
    * exceptions on failure.
    *
    * @param  string    Path to directory. The parent directory must exist and
    *                   be writable.
    * @param  int       Permission umask. Note that umask is in octal, so you
    *                   should specify it as, e.g., `0777', not `777'.
    * @param  boolean   Recursively create directories. Default to false.
    * @return string    Path to the created directory.
    *
    * @task   directory
    */
   public static function createDirectory(
     $path,
     $umask = 0755,
     $recursive = false) {
 
     $path = self::resolvePath($path);
 
     if (is_dir($path)) {
       if ($umask) {
         self::changePermissions($path, $umask);
       }
       return $path;
     }
 
     $dir = dirname($path);
     if ($recursive && !file_exists($dir)) {
       // Note: We could do this with the recursive third parameter of mkdir(),
       // but then we loose the helpful FilesystemExceptions we normally get.
       self::createDirectory($dir, $umask, true);
     }
 
     self::assertIsDirectory($dir);
     self::assertExists($dir);
     self::assertWritable($dir);
     self::assertNotExists($path);
 
     if (!mkdir($path, $umask)) {
       throw new FilesystemException(
         $path,
         pht("Failed to create directory '%s'.", $path));
     }
 
     // Need to change permissions explicitly because mkdir does something
     // slightly different. mkdir(2) man page:
     // 'The parameter mode specifies the permissions to use. It is modified by
     // the process's umask in the usual way: the permissions of the created
     // directory are (mode & ~umask & 0777)."'
     if ($umask) {
       self::changePermissions($path, $umask);
     }
 
     return $path;
   }
 
 
   /**
    * Create a temporary directory and return the path to it. You are
    * responsible for removing it (e.g., with Filesystem::remove())
    * when you are done with it.
    *
    * @param  string    Optional directory prefix.
    * @param  int       Permissions to create the directory with. By default,
    *                   these permissions are very restrictive (0700).
    * @param  string    Optional root directory. If not provided, the system
    *                   temporary directory (often "/tmp") will be used.
    * @return string    Path to newly created temporary directory.
    *
    * @task   directory
    */
   public static function createTemporaryDirectory(
     $prefix = '',
     $umask = 0700,
     $root_directory = null) {
     $prefix = preg_replace('/[^A-Z0-9._-]+/i', '', $prefix);
 
     if ($root_directory !== null) {
       $tmp = $root_directory;
       self::assertExists($tmp);
       self::assertIsDirectory($tmp);
       self::assertWritable($tmp);
     } else {
       $tmp = sys_get_temp_dir();
       if (!$tmp) {
         throw new FilesystemException(
           $tmp,
           pht('Unable to determine system temporary directory.'));
       }
     }
 
     $base = $tmp.DIRECTORY_SEPARATOR.$prefix;
 
     $tries = 3;
     do {
       $dir = $base.substr(base_convert(md5(mt_rand()), 16, 36), 0, 16);
       try {
         self::createDirectory($dir, $umask);
         break;
       } catch (FilesystemException $ex) {
         // Ignore.
       }
     } while (--$tries);
 
     if (!$tries) {
       $df = disk_free_space($tmp);
       if ($df !== false && $df < 1024 * 1024) {
         throw new FilesystemException(
           $dir,
           pht('Failed to create a temporary directory: the disk is full.'));
       }
 
       throw new FilesystemException(
         $dir,
         pht("Failed to create a temporary directory in '%s'.", $tmp));
     }
 
     return $dir;
   }
 
 
   /**
    * List files in a directory.
    *
    * @param  string    Path, absolute or relative to PWD.
    * @param  bool      If false, exclude files beginning with a ".".
    *
    * @return array     List of files and directories in the specified
    *                   directory, excluding `.' and `..'.
    *
    * @task   directory
    */
   public static function listDirectory($path, $include_hidden = true) {
     $path = self::resolvePath($path);
 
     self::assertExists($path);
     self::assertIsDirectory($path);
     self::assertReadable($path);
 
     $list = @scandir($path);
     if ($list === false) {
       throw new FilesystemException(
         $path,
         pht("Unable to list contents of directory '%s'.", $path));
     }
 
     foreach ($list as $k => $v) {
       if ($v == '.' || $v == '..' || (!$include_hidden && $v[0] == '.')) {
         unset($list[$k]);
       }
     }
 
     return array_values($list);
   }
 
 
   /**
    * Return all directories between a path and the specified root directory
    * (defaulting to "/"). Iterating over them walks from the path to the root.
    *
    * @param  string        Path, absolute or relative to PWD.
    * @param  string        The root directory.
    * @return list<string>  List of parent paths, including the provided path.
    * @task   directory
    */
   public static function walkToRoot($path, $root = null) {
     $path = self::resolvePath($path);
 
     if (is_link($path)) {
       $path = realpath($path);
     }
 
     // NOTE: On Windows, paths start like "C:\", so "/" does not contain
     // every other path. We could possibly special case "/" to have the same
     // meaning on Windows that it does on Linux, but just special case the
     // common case for now. See PHI817.
     if ($root !== null) {
       $root = self::resolvePath($root);
 
       if (is_link($root)) {
         $root = realpath($root);
       }
 
       // NOTE: We don't use `isDescendant()` here because we don't want to
       // reject paths which don't exist on disk.
       $root_list = new FileList(array($root));
       if (!$root_list->contains($path)) {
         return array();
       }
     } else {
       if (phutil_is_windows()) {
         $root = null;
       } else {
         $root = '/';
       }
     }
 
     $walk = array();
     $parts = explode(DIRECTORY_SEPARATOR, $path);
     foreach ($parts as $k => $part) {
       if (!strlen($part)) {
         unset($parts[$k]);
       }
     }
 
     while (true) {
       if (phutil_is_windows()) {
         $next = implode(DIRECTORY_SEPARATOR, $parts);
       } else {
         $next = DIRECTORY_SEPARATOR.implode(DIRECTORY_SEPARATOR, $parts);
       }
 
       $walk[] = $next;
       if ($next == $root) {
         break;
       }
 
       if (!$parts) {
         break;
       }
 
       array_pop($parts);
     }
 
     return $walk;
   }
 
 
 /* -(  Paths  )-------------------------------------------------------------- */
 
 
   /**
    * Checks if a path is specified as an absolute path.
    *
    * @param  string
    * @return bool
    */
   public static function isAbsolutePath($path) {
     if (phutil_is_windows()) {
       return (bool)preg_match('/^[A-Za-z]+:/', $path);
     } else {
       return !strncmp($path, DIRECTORY_SEPARATOR, 1);
     }
   }
 
   /**
    * Canonicalize a path by resolving it relative to some directory (by
    * default PWD), following parent symlinks and removing artifacts. If the
    * path is itself a symlink it is left unresolved.
    *
    * @param  string    Path, absolute or relative to PWD.
    * @return string    Canonical, absolute path.
    *
    * @task   path
    */
   public static function resolvePath($path, $relative_to = null) {
     $is_absolute = self::isAbsolutePath($path);
 
     if (!$is_absolute) {
       if (!$relative_to) {
         $relative_to = getcwd();
       }
       $path = $relative_to.DIRECTORY_SEPARATOR.$path;
     }
 
     if (is_link($path)) {
       $parent_realpath = realpath(dirname($path));
       if ($parent_realpath !== false) {
         return $parent_realpath.DIRECTORY_SEPARATOR.basename($path);
       }
     }
 
     $realpath = realpath($path);
     if ($realpath !== false) {
       return $realpath;
     }
 
 
     // This won't work if the file doesn't exist or is on an unreadable mount
     // or something crazy like that. Try to resolve a parent so we at least
     // cover the nonexistent file case.
-    $parts = explode(DIRECTORY_SEPARATOR, trim($path, DIRECTORY_SEPARATOR));
-    while (end($parts) !== false) {
+
+    // We're also normalizing path separators to whatever is normal for the
+    // environment.
+
+    if (phutil_is_windows()) {
+      $parts = trim($path, '/\\');
+      $parts = preg_split('([/\\\\])', $parts);
+
+      // Normalize the directory separators in the path. If we find a parent
+      // below, we'll overwrite this with a better resolved path.
+      $path = str_replace('/', '\\', $path);
+    } else {
+      $parts = trim($path, '/');
+      $parts = explode('/', $parts);
+    }
+
+    while ($parts) {
       array_pop($parts);
       if (phutil_is_windows()) {
         $attempt = implode(DIRECTORY_SEPARATOR, $parts);
       } else {
         $attempt = DIRECTORY_SEPARATOR.implode(DIRECTORY_SEPARATOR, $parts);
       }
       $realpath = realpath($attempt);
       if ($realpath !== false) {
         $path = $realpath.substr($path, strlen($attempt));
         break;
       }
     }
 
     return $path;
   }
 
   /**
    * Test whether a path is descendant from some root path after resolving all
    * symlinks and removing artifacts. Both paths must exists for the relation
    * to obtain. A path is always a descendant of itself as long as it exists.
    *
    * @param  string   Child path, absolute or relative to PWD.
    * @param  string   Root path, absolute or relative to PWD.
    * @return bool     True if resolved child path is in fact a descendant of
    *                  resolved root path and both exist.
    * @task   path
    */
   public static function isDescendant($path, $root) {
     try {
       self::assertExists($path);
       self::assertExists($root);
     } catch (FilesystemException $e) {
       return false;
     }
     $fs = new FileList(array($root));
     return $fs->contains($path);
   }
 
   /**
    * Convert a canonical path to its most human-readable format. It is
    * guaranteed that you can use resolvePath() to restore a path to its
    * canonical format.
    *
    * @param  string    Path, absolute or relative to PWD.
    * @param  string    Optionally, working directory to make files readable
    *                   relative to.
    * @return string    Human-readable path.
    *
    * @task   path
    */
   public static function readablePath($path, $pwd = null) {
     if ($pwd === null) {
       $pwd = getcwd();
     }
 
     foreach (array($pwd, self::resolvePath($pwd)) as $parent) {
       $parent = rtrim($parent, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
       $len = strlen($parent);
       if (!strncmp($parent, $path, $len)) {
         $path = substr($path, $len);
         return $path;
       }
     }
 
     return $path;
   }
 
   /**
    * Determine whether or not a path exists in the filesystem. This differs from
    * file_exists() in that it returns true for symlinks. This method does not
    * attempt to resolve paths before testing them.
    *
    * @param   string  Test for the existence of this path.
    * @return  bool    True if the path exists in the filesystem.
    * @task    path
    */
   public static function pathExists($path) {
     return file_exists($path) || is_link($path);
   }
 
 
   /**
    * Determine if an executable binary (like `git` or `svn`) exists within
    * the configured `$PATH`.
    *
    * @param   string  Binary name, like `'git'` or `'svn'`.
    * @return  bool    True if the binary exists and is executable.
    * @task    exec
    */
   public static function binaryExists($binary) {
     return self::resolveBinary($binary) !== null;
   }
 
 
   /**
    * Locates the full path that an executable binary (like `git` or `svn`) is at
    * the configured `$PATH`.
    *
    * @param   string  Binary name, like `'git'` or `'svn'`.
    * @return  string  The full binary path if it is present, or null.
    * @task    exec
    */
   public static function resolveBinary($binary) {
     if (phutil_is_windows()) {
       list($err, $stdout) = exec_manual('where %s', $binary);
       $stdout = phutil_split_lines($stdout);
 
       // If `where %s` could not find anything, check for relative binary
       if ($err) {
         $path = self::resolvePath($binary);
         if (self::pathExists($path)) {
           return $path;
         }
         return null;
       }
       $stdout = head($stdout);
     } else {
       list($err, $stdout) = exec_manual('which %s', $binary);
     }
 
     return $err === 0 ? trim($stdout) : null;
   }
 
 
   /**
    * Determine if two paths are equivalent by resolving symlinks. This is
    * different from resolving both paths and comparing them because
    * resolvePath() only resolves symlinks in parent directories, not the
    * path itself.
    *
    * @param string First path to test for equivalence.
    * @param string Second path to test for equivalence.
    * @return bool  True if both paths are equivalent, i.e. reference the same
    *               entity in the filesystem.
    * @task path
    */
   public static function pathsAreEquivalent($u, $v) {
     $u = self::resolvePath($u);
     $v = self::resolvePath($v);
 
     $real_u = realpath($u);
     $real_v = realpath($v);
 
     if ($real_u) {
       $u = $real_u;
     }
     if ($real_v) {
       $v = $real_v;
     }
     return ($u == $v);
   }
 
+  public static function concatenatePaths(array $components) {
+    $components = implode($components, DIRECTORY_SEPARATOR);
+
+    // Replace any extra sequences of directory separators with a single
+    // separator, so we don't end up with "path//to///thing.c".
+    $components = preg_replace(
+      '('.preg_quote(DIRECTORY_SEPARATOR).'{2,})',
+      DIRECTORY_SEPARATOR,
+      $components);
+
+    return $components;
+  }
 
 /* -(  Assert  )------------------------------------------------------------- */
 
 
   /**
    * Assert that something (e.g., a file, directory, or symlink) exists at a
    * specified location.
    *
    * @param  string    Assert that this path exists.
    * @return void
    *
    * @task   assert
    */
   public static function assertExists($path) {
     if (self::pathExists($path)) {
       return;
     }
 
     // Before we claim that the path doesn't exist, try to find a parent we
     // don't have "+x" on. If we find one, tailor the error message so we don't
     // say "does not exist" in cases where the path does exist, we just don't
     // have permission to test its existence.
     foreach (self::walkToRoot($path) as $parent) {
       if (!self::pathExists($parent)) {
         continue;
       }
 
       if (!is_dir($parent)) {
         continue;
       }
 
       if (phutil_is_windows()) {
         // Do nothing. On Windows, there's no obvious equivalent to the
         // check below because "is_executable(...)" always appears to return
         // "false" for any directory.
       } else if (!is_executable($parent)) {
         // On Linux, note that we don't need read permission ("+r") on parent
         // directories to determine that a path exists, only execute ("+x").
         throw new FilesystemException(
           $path,
           pht(
             'Filesystem path "%s" can not be accessed because a parent '.
             'directory ("%s") is not executable (the current process does '.
             'not have "+x" permission).',
             $path,
             $parent));
       }
     }
 
     throw new FilesystemException(
       $path,
       pht(
         'Filesystem path "%s" does not exist.',
         $path));
   }
 
 
   /**
    * Assert that nothing exists at a specified location.
    *
    * @param  string    Assert that this path does not exist.
    * @return void
    *
    * @task   assert
    */
   public static function assertNotExists($path) {
     if (file_exists($path) || is_link($path)) {
       throw new FilesystemException(
         $path,
         pht("Path '%s' already exists!", $path));
     }
   }
 
 
   /**
    * Assert that a path represents a file, strictly (i.e., not a directory).
    *
    * @param  string    Assert that this path is a file.
    * @return void
    *
    * @task   assert
    */
   public static function assertIsFile($path) {
     if (!is_file($path)) {
       throw new FilesystemException(
         $path,
         pht("Requested path '%s' is not a file.", $path));
     }
   }
 
 
   /**
    * Assert that a path represents a directory, strictly (i.e., not a file).
    *
    * @param  string    Assert that this path is a directory.
    * @return void
    *
    * @task   assert
    */
   public static function assertIsDirectory($path) {
     if (!is_dir($path)) {
       throw new FilesystemException(
         $path,
         pht("Requested path '%s' is not a directory.", $path));
     }
   }
 
 
   /**
    * Assert that a file or directory exists and is writable.
    *
    * @param  string    Assert that this path is writable.
    * @return void
    *
    * @task   assert
    */
   public static function assertWritable($path) {
     if (!is_writable($path)) {
       throw new FilesystemException(
         $path,
         pht("Requested path '%s' is not writable.", $path));
     }
   }
 
 
   /**
    * Assert that a file or directory exists and is readable.
    *
    * @param  string    Assert that this path is readable.
    * @return void
    *
    * @task   assert
    */
   public static function assertReadable($path) {
     if (!is_readable($path)) {
       throw new FilesystemException(
         $path,
         pht("Path '%s' is not readable.", $path));
     }
   }
 
 }
diff --git a/src/filesystem/__tests__/FileFinderTestCase.php b/src/filesystem/__tests__/FileFinderTestCase.php
index f7214bd1..d0a7459f 100644
--- a/src/filesystem/__tests__/FileFinderTestCase.php
+++ b/src/filesystem/__tests__/FileFinderTestCase.php
@@ -1,232 +1,243 @@
 <?php
 
 final class FileFinderTestCase extends PhutilTestCase {
 
   private function newFinder($directory = null) {
     if (!$directory) {
       $directory = dirname(__FILE__).'/data';
     }
 
     return id(new FileFinder($directory))
       ->excludePath('./exclude')
       ->excludePath('subdir.txt');
   }
 
   public function testFinderWithChecksums() {
     $this->assertFinder(
       pht('Basic Checksums'),
       $this->newFinder()
         ->setGenerateChecksums(true)
         ->withType('f')
         ->withPath('*')
         ->withSuffix('txt'),
       array(
         '.hidden.txt' =>
           'b6cfc9ce9afe12b258ee1c19c235aa27',
         'file.txt' =>
           '725130ba6441eadb4e5d807898e0beae',
         'include_dir.txt/anotherfile.txt' =>
           '91e5c1ad76ff229c6456ac92e74e1d9f',
         'include_dir.txt/subdir.txt/alsoinclude.txt' =>
           '91e5c1ad76ff229c6456ac92e74e1d9f',
         'test.txt' =>
           'aea46212fa8b8d0e0e6aa34a15c9e2f5',
       ));
   }
 
   public function testFinderWithoutChecksums() {
     $this->assertFinder(
       pht('Basic No Checksums'),
       $this->newFinder()
         ->withType('f')
         ->withPath('*')
         ->withSuffix('txt'),
       array(
         '.hidden.txt',
         'file.txt',
         'include_dir.txt/anotherfile.txt',
         'include_dir.txt/subdir.txt/alsoinclude.txt',
         'test.txt',
       ));
   }
 
   public function testFinderWithFilesAndDirectories() {
     $this->assertFinder(
       pht('With Files And Directories'),
       $this->newFinder()
         ->setGenerateChecksums(true)
         ->withPath('*')
         ->withSuffix('txt'),
       array(
         '.hidden.txt' =>
           'b6cfc9ce9afe12b258ee1c19c235aa27',
         'file.txt' =>
           '725130ba6441eadb4e5d807898e0beae',
         'include_dir.txt' => null,
         'include_dir.txt/anotherfile.txt' =>
           '91e5c1ad76ff229c6456ac92e74e1d9f',
         'include_dir.txt/subdir.txt' => null,
         'include_dir.txt/subdir.txt/alsoinclude.txt' =>
           '91e5c1ad76ff229c6456ac92e74e1d9f',
         'test.txt' =>
           'aea46212fa8b8d0e0e6aa34a15c9e2f5',
       ));
   }
 
   public function testFinderWithDirectories() {
     $this->assertFinder(
       pht('Just Directories'),
       $this->newFinder()
         ->withType('d'),
       array(
         'include_dir.txt',
         'include_dir.txt/subdir.txt',
       ));
   }
 
   public function testFinderWithPath() {
     $this->assertFinder(
       pht('With Path'),
       $this->newFinder()
         ->setGenerateChecksums(true)
         ->withType('f')
         ->withPath('*/include_dir.txt/subdir.txt/alsoinclude.txt')
         ->withSuffix('txt'),
       array(
         'include_dir.txt/subdir.txt/alsoinclude.txt' =>
           '91e5c1ad76ff229c6456ac92e74e1d9f',
       ));
   }
 
   public function testFinderWithNames() {
     $this->assertFinder(
       pht('With Names'),
       $this->newFinder()
         ->withType('f')
         ->withPath('*')
         ->withName('test'),
       array(
         'include_dir.txt/subdir.txt/test',
         'include_dir.txt/test',
         'test',
       ));
   }
 
   public function testFinderWithNameAndSuffix() {
     $this->assertFinder(
       pht('With Name and Suffix'),
       $this->newFinder()
         ->withType('f')
         ->withName('alsoinclude.txt')
         ->withSuffix('txt'),
       array(
         'include_dir.txt/subdir.txt/alsoinclude.txt',
       ));
   }
 
   public function testFinderWithGlobMagic() {
+    if (phutil_is_windows()) {
+      // We can't write files with "\" since this is the path separator.
+      // We can't write files with "*" since Windows rejects them.
+      // This doesn't leave us too many interesting paths to test, so just
+      // skip this test case under Windows.
+      $this->assertSkipped(
+        pht(
+          'Windows can not write files with sufficiently absurd names.'));
+    }
+
     // Fill a temporary directory with all this magic garbage so we don't have
     // to check a bunch of files with backslashes in their names into version
     // control.
     $tmp_dir = Filesystem::createTemporaryDirectory();
 
     $crazy_magic = array(
       'backslash\\.\\*',
       'star-*.*',
       'star-*.txt',
       'star.t*t',
       'star.tesseract',
     );
 
     foreach ($crazy_magic as $sketchy_path) {
       Filesystem::writeFile($tmp_dir.'/'.$sketchy_path, '.');
     }
 
     $this->assertFinder(
       pht('Glob Magic, Literal .t*t'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withSuffix('t*t'),
       array(
         'star.t*t',
       ));
 
     $this->assertFinder(
       pht('Glob Magic, .tesseract'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withSuffix('tesseract'),
       array(
         'star.tesseract',
       ));
 
     $this->assertFinder(
       pht('Glob Magic, Name'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withName('star-*'),
       array());
 
     $this->assertFinder(
       pht('Glob Magic, Name + Suffix'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withName('star-*.*'),
       array(
         'star-*.*',
       ));
 
     $this->assertFinder(
       pht('Glob Magic, Backslash Suffix'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withSuffix('\\*'),
       array(
         'backslash\\.\\*',
       ));
 
     $this->assertFinder(
       pht('Glob Magic, With Globs'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withNameGlob('star-*'),
       array(
         'star-*.*',
         'star-*.txt',
       ));
 
     $this->assertFinder(
       pht('Glob Magic, With Globs + Suffix'),
       $this->newFinder($tmp_dir)
         ->withType('f')
         ->withNameGlob('star-*')
         ->withSuffix('txt'),
       array(
         'star-*.txt',
       ));
   }
 
   private function assertFinder($label, FileFinder $finder, $expect) {
     $modes = array(
       'php',
       'shell',
     );
+
     foreach ($modes as $mode) {
       $actual = id(clone $finder)
         ->setForceMode($mode)
         ->find();
 
       if ($finder->getGenerateChecksums()) {
         ksort($actual);
       } else {
         sort($actual);
       }
 
       $this->assertEqual(
         $expect,
         $actual,
         pht('Test Case "%s" in Mode "%s"', $label, $mode));
     }
   }
 
 }
diff --git a/src/filesystem/__tests__/FilesystemTestCase.php b/src/filesystem/__tests__/FilesystemTestCase.php
index b04de456..a3aff733 100644
--- a/src/filesystem/__tests__/FilesystemTestCase.php
+++ b/src/filesystem/__tests__/FilesystemTestCase.php
@@ -1,216 +1,222 @@
 <?php
 
 final class FilesystemTestCase extends PhutilTestCase {
 
   public function testBinaryExists() {
     // Test for the `which` binary on Linux, and the `where` binary on Windows,
     // because `which which` is cute.
 
     if (phutil_is_windows()) {
       $exists = 'where';
     } else {
       $exists = 'which';
     }
 
     $this->assertEqual(
       true,
       Filesystem::binaryExists($exists));
 
     // We don't expect to find this binary on any system.
 
     $this->assertEqual(
       false,
       Filesystem::binaryExists('halting-problem-decider'));
   }
 
   public function testResolveBinary() {
     // Test to make sure resolveBinary() returns the full path to the `which`
     // and `where` binaries.
 
     if (phutil_is_windows()) {
       $binary = 'where';
     } else {
       $binary = 'which';
     }
 
     $path = Filesystem::resolveBinary($binary);
     $this->assertFalse(null === $path);
     $this->assertTrue(file_exists($path));
     $this->assertFalse(is_dir($path));
 
     $this->assertEqual(null,
       Filesystem::resolveBinary('halting-problem-decider'));
   }
 
   public function testWriteUniqueFile() {
     $tmp = new TempFile();
     $dir = dirname($tmp);
 
     // Writing an empty file should work.
     $f = Filesystem::writeUniqueFile($dir, '');
     $this->assertEqual('', Filesystem::readFile($f));
 
     // File name should be unique.
     $g = Filesystem::writeUniqueFile($dir, 'quack');
     $this->assertTrue($f != $g);
   }
 
   public function testReadRandomBytes() {
     $number_of_bytes = 1024;
     $data = Filesystem::readRandomBytes($number_of_bytes);
     $this->assertTrue(strlen($data) == $number_of_bytes);
 
     $data1 = Filesystem::readRandomBytes(128);
     $data2 = Filesystem::readRandomBytes(128);
     $this->assertFalse($data1 == $data2);
 
     $caught = null;
     try {
       Filesystem::readRandomBytes(0);
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue($caught instanceof Exception);
   }
 
   public function testWalkToRoot() {
     $test_cases = array(
       array(
         dirname(__FILE__).'/data/include_dir.txt/subdir.txt/test',
         dirname(__FILE__),
         array(
           dirname(__FILE__).'/data/include_dir.txt/subdir.txt/test',
           dirname(__FILE__).'/data/include_dir.txt/subdir.txt',
           dirname(__FILE__).'/data/include_dir.txt',
           dirname(__FILE__).'/data',
           dirname(__FILE__),
         ),
       ),
       array(
         dirname(__FILE__).'/data/include_dir.txt/subdir.txt',
         dirname(__FILE__),
         array(
           dirname(__FILE__).'/data/include_dir.txt/subdir.txt',
           dirname(__FILE__).'/data/include_dir.txt',
           dirname(__FILE__).'/data',
           dirname(__FILE__),
         ),
       ),
 
       'root and path are identical' => array(
         dirname(__FILE__),
         dirname(__FILE__),
         array(
           dirname(__FILE__),
         ),
       ),
 
       'root is not an ancestor of path' => array(
         dirname(__FILE__),
         dirname(__FILE__).'/data/include_dir.txt/subdir.txt',
         array(),
       ),
 
       'fictional paths work' => array(
         '/x/y/z',
         '/',
         array(
           '/x/y/z',
           '/x/y',
           '/x',
           '/',
         ),
       ),
 
     );
 
     foreach ($test_cases as $test_case) {
       list($path, $root, $expected) = $test_case;
 
+      // On Windows, paths will have backslashes rather than forward slashes.
+      // Normalize our expectations to the path format for the environment.
+      foreach ($expected as $key => $epath) {
+        $expected[$key] = str_replace('/', DIRECTORY_SEPARATOR, $epath);
+      }
+
       $this->assertEqual(
         $expected,
         Filesystem::walkToRoot($path, $root));
     }
   }
 
   public function testisDescendant() {
     $test_cases = array(
       array(
         __FILE__,
         dirname(__FILE__),
         true,
       ),
       array(
         dirname(__FILE__),
         dirname(dirname(__FILE__)),
         true,
       ),
       array(
         dirname(__FILE__),
         phutil_get_library_root_for_path(__FILE__),
         true,
       ),
       array(
         dirname(dirname(__FILE__)),
         dirname(__FILE__),
         false,
       ),
       array(
         dirname(__FILE__).'/quack',
         dirname(__FILE__),
         false,
       ),
     );
 
     foreach ($test_cases as $test_case) {
       list($path, $root, $expected) = $test_case;
 
       $this->assertEqual(
         $expected,
         Filesystem::isDescendant($path, $root),
         sprintf(
           'Filesystem::isDescendant(%s, %s)',
           phutil_var_export($path),
           phutil_var_export($root)));
     }
   }
 
   public function testRandomIntegers() {
     $valid_ranges = array(
       array(5, 5),
       array(-1, 1),
       array(0, 10000),
       array(0, 999999999),
       array(-65535, 65536),
     );
 
     foreach ($valid_ranges as $case) {
       list($min, $max) = $case;
 
       $result = Filesystem::readRandomInteger($min, $max);
 
       $this->assertTrue($min <= $result, pht('%d <= %d', $min, $result));
       $this->assertTrue($max >= $result, pht('%d >= %d', $max, $result));
     }
 
     $invalid_ranges = array(
       array('1', '2'),
       array(1.0, 2.0),
       array(5, 3),
     );
 
     foreach ($invalid_ranges as $case) {
       list($min, $max) = $case;
 
       $caught = null;
       try {
         Filesystem::readRandomInteger($min, $max);
       } catch (Exception $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue($caught instanceof Exception);
     }
   }
 
 }
diff --git a/src/filesystem/__tests__/PhutilFileLockTestCase.php b/src/filesystem/__tests__/PhutilFileLockTestCase.php
index 9dcc2c30..6d91205f 100644
--- a/src/filesystem/__tests__/PhutilFileLockTestCase.php
+++ b/src/filesystem/__tests__/PhutilFileLockTestCase.php
@@ -1,186 +1,190 @@
 <?php
 
 final class PhutilFileLockTestCase extends PhutilTestCase {
 
   public function testLockTesting() {
     // We should be able to acquire locks.
 
     $file = new TempFile();
 
     $this->assertTrue($this->lockTest($file));
 
     $this->assertTrue($this->lockTest($file));
   }
 
   public function testLockHolding() {
     // When a process is holding a lock, other processes should be unable
     // to acquire it.
 
     $file = new TempFile();
     $hold = $this->holdLock($file);
 
     $this->assertFalse($this->lockTest($file));
 
     $hold->resolveKill();
 
     $this->assertTrue($this->lockTest($file));
   }
 
   public function testInProcessLocking() {
     // Other processes should be unable to lock a file if we hold the lock.
 
     $file = new TempFile();
 
     $lock = PhutilFileLock::newForPath($file);
     $lock->lock();
 
     $this->assertFalse($this->lockTest($file));
 
     $lock->unlock();
 
     $this->assertTrue($this->lockTest($file));
   }
 
   public function testInProcessHolding() {
     // We should be unable to lock a file if another process is holding the
     // lock.
 
     $file = new TempFile();
     $lock = PhutilFileLock::newForPath($file);
 
     $hold = $this->holdLock($file);
     $caught = null;
     try {
       $lock->lock();
     } catch (PhutilLockException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof PhutilLockException);
 
     $hold->resolveKill();
 
     $this->assertTrue($this->lockTest($file));
 
     $lock->lock();
     $lock->unlock();
   }
 
   public function testRelock() {
     // Trying to lock a file twice should throw an exception.
 
     $file = new TempFile();
     $lock = PhutilFileLock::newForPath($file);
     $lock->lock();
 
     $caught = null;
     try {
       $lock->lock();
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof Exception);
   }
 
   public function testExcessiveUnlock() {
     // Trying to unlock a file twice should throw an exception.
 
     $file = new TempFile();
     $lock = PhutilFileLock::newForPath($file);
     $lock->lock();
 
     $lock->unlock();
 
     $caught = null;
     try {
       $lock->unlock();
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof Exception);
   }
 
   public function testUnlockAll() {
     // unlockAll() should release all locks.
 
     $file = new TempFile();
     $lock = PhutilFileLock::newForPath($file);
 
     $lock->lock();
 
     $this->assertFalse($this->lockTest($file));
 
     PhutilFileLock::unlockAll();
 
     $this->assertTrue($this->lockTest($file));
 
     // Calling this again shouldn't do anything bad.
     PhutilFileLock::unlockAll();
 
     $this->assertTrue($this->lockTest($file));
 
     $lock->lock();
     $lock->unlock();
   }
 
   public function testIsLocked() {
     // isLocked() should report lock status accurately.
 
     $file = new TempFile();
     $lock = PhutilFileLock::newForPath($file);
 
     $this->assertFalse($lock->isLocked());
 
     $lock->lock();
 
     $this->assertTrue($lock->isLocked());
 
     $lock->unlock();
 
     $this->assertFalse($lock->isLocked());
   }
 
   private function lockTest($file) {
     list($err) = $this->buildLockFuture('--test', $file)->resolve();
     return ($err == 0);
   }
 
   private function holdLock($file) {
     $future = $this->buildLockFuture('--hold', $file);
 
     // We can't return until we're sure the subprocess has had time to acquire
     // the lock. Since actually testing for the lock would be kind of silly
     // and guarantee that we loop forever if the locking primitive broke,
     // watch stdout for a *claim* that it has acquired the lock instead.
 
     // Make sure we don't loop forever, no matter how bad things get.
     $future->setTimeout(30);
 
     $buf = '';
     while (!$future->isReady()) {
       list($stdout) = $future->read();
       $buf .= $stdout;
       if (strpos($buf, 'LOCK ACQUIRED') !== false) {
         return $future;
       }
     }
 
     throw new Exception(pht('Unable to hold lock in external process!'));
   }
 
-  private function buildLockFuture($flags, $file) {
-    $root = dirname(phutil_get_library_root('arcanist'));
-    $bin = $root.'/support/test/lock-file.php';
-
-    $flags = (array)$flags;
+  private function buildLockFuture(/* ... */) {
+    $argv = func_get_args();
+    $bin = $this->getSupportExecutable('lock');
+
+    if (phutil_is_windows()) {
+      $future = new ExecFuture('php -f %R -- %Ls', $bin, $argv);
+    } else {
+      // NOTE: Use `exec` so this passes on Ubuntu, where the default `dash`
+      // shell will eat any kills we send during the tests.
+      $future = new ExecFuture('exec php -f %R -- %Ls', $bin, $argv);
+    }
 
-    // NOTE: Use `exec` so this passes on Ubuntu, where the default `dash` shell
-    // will eat any kills we send during the tests.
-    $future = new ExecFuture('exec php -f %R -- %Ls %R', $bin, $flags, $file);
     $future->start();
+
     return $future;
   }
 
 }
diff --git a/src/filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php b/src/filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php
index fc552637..90d40737 100644
--- a/src/filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php
+++ b/src/filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php
@@ -1,62 +1,64 @@
 <?php
 
 final class LinesOfALargeExecFutureTestCase extends PhutilTestCase {
 
   // Most of the core functionality of LinesOfALarge is covered by the
   // LinesOfALargeFile test case, try to just cover exec-specific stuff here.
 
   public function testExecBasics() {
     $this->writeAndRead(
       "cat\ndog\nbird\n",
       array(
         'cat',
         'dog',
         'bird',
       ));
   }
 
   public function testExecLargeFile() {
     $line = pht('The quick brown fox jumps over the lazy dog.');
     $n    = 100;
 
     $this->writeAndRead(
       str_repeat($line."\n", $n),
       array_fill(0, $n, $line));
   }
 
   public function testExecLongLine() {
     $line = str_repeat('x', 64 * 1024);
     $this->writeAndRead($line, array($line));
   }
 
   public function testExecException() {
     $caught = null;
     try {
       $future = new ExecFuture('does-not-exist.exe.sh');
       foreach (new LinesOfALargeExecFuture($future) as $line) {
         // ignore
       }
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue($caught instanceof CommandException);
   }
 
   private function writeAndRead($write, $read) {
-    $future = new ExecFuture('cat');
+    $bin = $this->getSupportExecutable('cat');
+    $future = new ExecFuture('php -f %R', $bin);
+
     $future->write($write);
 
     $lines = array();
     foreach (new LinesOfALargeExecFuture($future) as $line) {
       $lines[] = $line;
     }
 
     $this->assertEqual(
       $read,
       $lines,
       pht('Write: %s', id(new PhutilUTF8StringTruncator())
         ->setMaximumGlyphs(32)
         ->truncateString($write)));
   }
 
 }
diff --git a/src/future/__tests__/FutureIteratorTestCase.php b/src/future/__tests__/FutureIteratorTestCase.php
index a310ee23..6590583c 100644
--- a/src/future/__tests__/FutureIteratorTestCase.php
+++ b/src/future/__tests__/FutureIteratorTestCase.php
@@ -1,23 +1,25 @@
 <?php
 
 final class FutureIteratorTestCase extends PhutilTestCase {
 
   public function testAddingFuture() {
-    $future1 = new ExecFuture('cat');
-    $future2 = new ExecFuture('cat');
+    $bin = $this->getSupportExecutable('cat');
+
+    $future1 = new ExecFuture('php -f %R', $bin);
+    $future2 = new ExecFuture('php -f %R', $bin);
 
     $iterator = new FutureIterator(array($future1));
     $iterator->limit(2);
 
     $results = array();
     foreach ($iterator as $future) {
       if ($future === $future1) {
         $iterator->addFuture($future2);
       }
       $results[] = $future->resolve();
     }
 
     $this->assertEqual(2, count($results));
   }
 
 }
diff --git a/src/future/exec/ExecFuture.php b/src/future/exec/ExecFuture.php
index 5e0f0062..2eb41ebd 100644
--- a/src/future/exec/ExecFuture.php
+++ b/src/future/exec/ExecFuture.php
@@ -1,976 +1,988 @@
 <?php
 
 /**
  * Execute system commands in parallel using futures.
  *
  * ExecFuture is a future, which means it runs asynchronously and represents
  * a value which may not exist yet. See @{article:Using Futures} for an
  * explanation of futures. When an ExecFuture resolves, it returns the exit
  * code, stdout and stderr of the process it executed.
  *
  * ExecFuture is the core command execution implementation in libphutil, but is
  * exposed through a number of APIs. See @{article:Command Execution} for more
  * discussion about executing system commands.
  *
  * @task create   Creating ExecFutures
  * @task resolve  Resolving Execution
  * @task config   Configuring Execution
  * @task info     Command Information
  * @task interact Interacting With Commands
  * @task internal Internals
  */
 final class ExecFuture extends PhutilExecutableFuture {
 
   private $pipes        = array();
   private $proc         = null;
   private $start        = null;
   private $procStatus   = null;
 
   private $stdout       = null;
   private $stderr       = null;
   private $stdin        = null;
   private $closePipe    = true;
 
   private $stdoutPos    = 0;
   private $stderrPos    = 0;
   private $command      = null;
 
   private $readBufferSize;
   private $stdoutSizeLimit = PHP_INT_MAX;
   private $stderrSizeLimit = PHP_INT_MAX;
 
   private $profilerCallID;
   private $killedByTimeout;
 
-  private $useWindowsFileStreams = false;
   private $windowsStdoutTempFile = null;
   private $windowsStderrTempFile = null;
 
   private $terminateTimeout;
   private $didTerminate;
   private $killTimeout;
 
   private static $descriptorSpec = array(
     0 => array('pipe', 'r'),  // stdin
     1 => array('pipe', 'w'),  // stdout
     2 => array('pipe', 'w'),  // stderr
   );
 
 
 /* -(  Creating ExecFutures  )----------------------------------------------- */
 
 
   /**
    * Create a new ExecFuture.
    *
    *   $future = new ExecFuture('wc -l %s', $file_path);
    *
    * @param string  `sprintf()`-style command string which will be passed
    *                through @{function:csprintf} with the rest of the arguments.
    * @param ...     Zero or more additional arguments for @{function:csprintf}.
    * @return ExecFuture ExecFuture for running the specified command.
    * @task create
    */
   public function __construct($command) {
     $argv = func_get_args();
     $this->command = call_user_func_array('csprintf', $argv);
     $this->stdin = new PhutilRope();
   }
 
 
 /* -(  Command Information  )------------------------------------------------ */
 
 
   /**
    * Retrieve the raw command to be executed.
    *
    * @return string Raw command.
    * @task info
    */
   public function getCommand() {
     return $this->command;
   }
 
 
   /**
    * Retrieve the byte limit for the stderr buffer.
    *
    * @return int Maximum buffer size, in bytes.
    * @task info
    */
   public function getStderrSizeLimit() {
     return $this->stderrSizeLimit;
   }
 
 
   /**
    * Retrieve the byte limit for the stdout buffer.
    *
    * @return int Maximum buffer size, in bytes.
    * @task info
    */
   public function getStdoutSizeLimit() {
     return $this->stdoutSizeLimit;
   }
 
 
   /**
    * Get the process's pid. This only works after execution is initiated, e.g.
    * by a call to start().
    *
    * @return int Process ID of the executing process.
    * @task info
    */
   public function getPID() {
     $status = $this->procGetStatus();
     return $status['pid'];
   }
 
 
 /* -(  Configuring Execution  )---------------------------------------------- */
 
 
   /**
    * Set a maximum size for the stdout read buffer. To limit stderr, see
    * @{method:setStderrSizeLimit}. The major use of these methods is to use less
    * memory if you are running a command which sometimes produces huge volumes
    * of output that you don't really care about.
    *
    * NOTE: Setting this to 0 means "no buffer", not "unlimited buffer".
    *
    * @param int Maximum size of the stdout read buffer.
    * @return this
    * @task config
    */
   public function setStdoutSizeLimit($limit) {
     $this->stdoutSizeLimit = $limit;
     return $this;
   }
 
 
   /**
    * Set a maximum size for the stderr read buffer.
    * See @{method:setStdoutSizeLimit} for discussion.
    *
    * @param int Maximum size of the stderr read buffer.
    * @return this
    * @task config
    */
   public function setStderrSizeLimit($limit) {
     $this->stderrSizeLimit = $limit;
     return $this;
   }
 
 
   /**
    * Set the maximum internal read buffer size this future. The future will
    * block reads once the internal stdout or stderr buffer exceeds this size.
    *
    * NOTE: If you @{method:resolve} a future with a read buffer limit, you may
    * block forever!
    *
    * TODO: We should probably release the read buffer limit during
    * @{method:resolve}, or otherwise detect this. For now, be careful.
    *
    * @param int|null Maximum buffer size, or `null` for unlimited.
    * @return this
    */
   public function setReadBufferSize($read_buffer_size) {
     $this->readBufferSize = $read_buffer_size;
     return $this;
   }
 
 
-  /**
-   * Set whether to use non-blocking streams on Windows.
-   *
-   * @param bool Whether to use non-blocking streams.
-   * @return this
-   * @task config
-   */
-  public function setUseWindowsFileStreams($use_streams) {
-    if (phutil_is_windows()) {
-      $this->useWindowsFileStreams = $use_streams;
-    }
-    return $this;
-  }
-
-
 /* -(  Interacting With Commands  )------------------------------------------ */
 
 
   /**
    * Read and return output from stdout and stderr, if any is available. This
    * method keeps a read cursor on each stream, but the entire streams are
    * still returned when the future resolves. You can call read() again after
    * resolving the future to retrieve only the parts of the streams you did not
    * previously read:
    *
    *   $future = new ExecFuture('...');
    *   // ...
    *   list($stdout) = $future->read(); // Returns output so far
    *   list($stdout) = $future->read(); // Returns new output since first call
    *   // ...
    *   list($stdout) = $future->resolvex(); // Returns ALL output
    *   list($stdout) = $future->read(); // Returns unread output
    *
    * NOTE: If you set a limit with @{method:setStdoutSizeLimit} or
    * @{method:setStderrSizeLimit}, this method will not be able to read data
    * past the limit.
    *
    * NOTE: If you call @{method:discardBuffers}, all the stdout/stderr data
    * will be thrown away and the cursors will be reset.
    *
    * @return pair <$stdout, $stderr> pair with new output since the last call
    *              to this method.
    * @task interact
    */
   public function read() {
     $stdout = $this->readStdout();
 
     $result = array(
       $stdout,
       (string)substr($this->stderr, $this->stderrPos),
     );
 
     $this->stderrPos = strlen($this->stderr);
 
     return $result;
   }
 
   public function readStdout() {
     if ($this->start) {
       $this->isReady(); // Sync
     }
 
     $result = (string)substr($this->stdout, $this->stdoutPos);
     $this->stdoutPos = strlen($this->stdout);
     return $result;
   }
 
 
   /**
    * Write data to stdin of the command.
    *
    * @param string Data to write.
    * @param bool If true, keep the pipe open for writing. By default, the pipe
    *             will be closed as soon as possible so that commands which
    *             listen for EOF will execute. If you want to keep the pipe open
    *             past the start of command execution, do an empty write with
    *             `$keep_pipe = true` first.
    * @return this
    * @task interact
    */
   public function write($data, $keep_pipe = false) {
     if (strlen($data)) {
       if (!$this->stdin) {
         throw new Exception(pht('Writing to a closed pipe!'));
       }
       $this->stdin->append($data);
     }
     $this->closePipe = !$keep_pipe;
 
     return $this;
   }
 
 
   /**
    * Permanently discard the stdout and stderr buffers and reset the read
    * cursors. This is basically useful only if you are streaming a large amount
    * of data from some process:
    *
    *   $future = new ExecFuture('zcat huge_file.gz');
    *   do {
    *     $done = $future->resolve(0.1);   // Every 100ms,
    *     list($stdout) = $future->read(); // read output...
    *     echo $stdout;                    // send it somewhere...
    *     $future->discardBuffers();       // and then free the buffers.
    *   } while ($done === null);
    *
    * Conceivably you might also need to do this if you're writing a client using
    * @{class:ExecFuture} and `netcat`, but you probably should not do that.
    *
    * NOTE: This completely discards the data. It won't be available when the
    * future resolves. This is almost certainly only useful if you need the
    * buffer memory for some reason.
    *
    * @return this
    * @task interact
    */
   public function discardBuffers() {
     $this->discardStdoutBuffer();
 
     $this->stderr = '';
     $this->stderrPos = 0;
 
     return $this;
   }
 
   public function discardStdoutBuffer() {
     $this->stdout = '';
     $this->stdoutPos = 0;
     return $this;
   }
 
 
   /**
    * Returns true if this future was killed by a timeout configured with
    * @{method:setTimeout}.
    *
    * @return bool True if the future was killed for exceeding its time limit.
    */
   public function getWasKilledByTimeout() {
     return $this->killedByTimeout;
   }
 
 
 /* -(  Configuring Execution  )---------------------------------------------- */
 
 
   /**
    * Set a hard limit on execution time. If the command runs longer, it will
    * be terminated and the future will resolve with an error code. You can test
    * if a future was killed by a timeout with @{method:getWasKilledByTimeout}.
    *
    * The subprocess will be sent a `TERM` signal, and then a `KILL` signal a
    * short while later if it fails to exit.
    *
    * @param int Maximum number of seconds this command may execute for before
    *  it is signaled.
    * @return this
    * @task config
    */
   public function setTimeout($seconds) {
     $this->terminateTimeout = $seconds;
     $this->killTimeout = $seconds + min($seconds, 60);
     return $this;
   }
 
 
 /* -(  Resolving Execution  )------------------------------------------------ */
 
 
   /**
    * Resolve a command you expect to exit with return code 0. Works like
    * @{method:resolve}, but throws if $err is nonempty. Returns only
    * $stdout and $stderr. See also @{function:execx}.
    *
    *   list($stdout, $stderr) = $future->resolvex();
    *
    * @param  float Optional timeout after which resolution will pause and
    *               execution will return to the caller.
    * @return pair  <$stdout, $stderr> pair.
    * @task resolve
    */
   public function resolvex($timeout = null) {
     list($err, $stdout, $stderr) = $this->resolve($timeout);
     if ($err) {
       $cmd = $this->command;
 
       if ($this->getWasKilledByTimeout()) {
         // NOTE: The timeout can be a float and PhutilNumber only handles
         // integers, so just use "%s" to render it.
         $message = pht(
           'Command killed by timeout after running for more than %s seconds.',
           $this->terminateTimeout);
       } else {
         $message = pht('Command failed with error #%d!', $err);
       }
 
       throw new CommandException(
         $message,
         $cmd,
         $err,
         $stdout,
         $stderr);
     }
     return array($stdout, $stderr);
   }
 
 
   /**
    * Resolve a command you expect to return valid JSON. Works like
    * @{method:resolvex}, but also throws if stderr is nonempty, or stdout is not
    * valid JSON. Returns a PHP array, decoded from the JSON command output.
    *
    * @param  float Optional timeout after which resolution will pause and
    *               execution will return to the caller.
    * @return array PHP array, decoded from JSON command output.
    * @task resolve
    */
   public function resolveJSON($timeout = null) {
     list($stdout, $stderr) = $this->resolvex($timeout);
     if (strlen($stderr)) {
       $cmd = $this->command;
       throw new CommandException(
         pht(
           "JSON command '%s' emitted text to stderr when none was expected: %d",
           $cmd,
           $stderr),
         $cmd,
         0,
         $stdout,
         $stderr);
     }
     try {
       return phutil_json_decode($stdout);
     } catch (PhutilJSONParserException $ex) {
       $cmd = $this->command;
       throw new CommandException(
         pht(
           "JSON command '%s' did not produce a valid JSON object on stdout: %s",
           $cmd,
           $stdout),
         $cmd,
         0,
         $stdout,
         $stderr);
     }
   }
 
   /**
    * Resolve the process by abruptly terminating it.
    *
    * @return list List of <err, stdout, stderr> results.
    * @task resolve
    */
   public function resolveKill() {
     if (!$this->result) {
       $signal = 9;
 
       if ($this->proc) {
         proc_terminate($this->proc, $signal);
       }
 
       $this->result = array(
         128 + $signal,
         $this->stdout,
         $this->stderr,
       );
       $this->closeProcess();
     }
 
     return $this->result;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Provides read sockets to the future core.
    *
    * @return list List of read sockets.
    * @task internal
    */
   public function getReadSockets() {
     list($stdin, $stdout, $stderr) = $this->pipes;
     $sockets = array();
     if (isset($stdout) && !feof($stdout)) {
       $sockets[] = $stdout;
     }
     if (isset($stderr) && !feof($stderr)) {
       $sockets[] = $stderr;
     }
     return $sockets;
   }
 
 
   /**
    * Provides write sockets to the future core.
    *
    * @return list List of write sockets.
    * @task internal
    */
   public function getWriteSockets() {
     list($stdin, $stdout, $stderr) = $this->pipes;
     $sockets = array();
     if (isset($stdin) && $this->stdin->getByteLength() && !feof($stdin)) {
       $sockets[] = $stdin;
     }
     return $sockets;
   }
 
 
   /**
    * Determine if the read buffer is empty.
    *
    * @return bool True if the read buffer is empty.
    * @task internal
    */
   public function isReadBufferEmpty() {
     return !strlen($this->stdout);
   }
 
 
   /**
    * Determine if the write buffer is empty.
    *
    * @return bool True if the write buffer is empty.
    * @task internal
    */
   public function isWriteBufferEmpty() {
     return !$this->getWriteBufferSize();
   }
 
 
   /**
    * Determine the number of bytes in the write buffer.
    *
    * @return int Number of bytes in the write buffer.
    * @task internal
    */
   public function getWriteBufferSize() {
     if (!$this->stdin) {
       return 0;
     }
     return $this->stdin->getByteLength();
   }
 
 
   /**
    * Reads some bytes from a stream, discarding output once a certain amount
    * has been accumulated.
    *
    * @param resource  Stream to read from.
    * @param int       Maximum number of bytes to return from $stream. If
    *                  additional bytes are available, they will be read and
    *                  discarded.
    * @param string    Human-readable description of stream, for exception
    *                  message.
    * @param int       Maximum number of bytes to read.
    * @return string   The data read from the stream.
    * @task internal
    */
   private function readAndDiscard($stream, $limit, $description, $length) {
     $output = '';
 
     if ($length <= 0) {
       return '';
     }
 
     do {
       $data = fread($stream, min($length, 64 * 1024));
       if (false === $data) {
         throw new Exception(pht('Failed to read from %s', $description));
       }
 
       $read_bytes = strlen($data);
 
       if ($read_bytes > 0 && $limit > 0) {
         if ($read_bytes > $limit) {
           $data = substr($data, 0, $limit);
         }
         $output .= $data;
         $limit -= strlen($data);
       }
 
       if (strlen($output) >= $length) {
         break;
       }
     } while ($read_bytes > 0);
 
     return $output;
   }
 
 
   /**
    * Begin or continue command execution.
    *
    * @return bool True if future has resolved.
    * @task internal
    */
   public function isReady() {
     // NOTE: We have soft dependencies on PhutilServiceProfiler and
     // PhutilErrorTrap here. These dependencies are soft to avoid the need to
     // build them into the Phage agent. Under normal circumstances, these
     // classes are always available.
 
     if (!$this->pipes) {
+      $is_windows = phutil_is_windows();
 
       // NOTE: See note above about Phage.
       if (class_exists('PhutilServiceProfiler')) {
         $profiler = PhutilServiceProfiler::getInstance();
         $this->profilerCallID = $profiler->beginServiceCall(
           array(
             'type'    => 'exec',
             'command' => (string)$this->command,
           ));
       }
 
       if (!$this->start) {
         // We might already have started the timer via initiating resolution.
         $this->start = microtime(true);
       }
 
       $unmasked_command = $this->command;
       if ($unmasked_command instanceof PhutilCommandString) {
         $unmasked_command = $unmasked_command->getUnmaskedString();
       }
 
       $pipes = array();
 
-      if (phutil_is_windows()) {
-        // See T4395. proc_open under Windows uses "cmd /C [cmd]", which will
-        // strip the first and last quote when there aren't exactly two quotes
-        // (and some other conditions as well). This results in a command that
-        // looks like `command" "path to my file" "something something` which is
-        // clearly wrong. By surrounding the command string with quotes we can
-        // be sure this process is harmless.
-        if (strpos($unmasked_command, '"') !== false) {
-          $unmasked_command = '"'.$unmasked_command.'"';
-        }
-      }
-
       if ($this->hasEnv()) {
         $env = $this->getEnv();
       } else {
         $env = null;
       }
 
       $cwd = $this->getCWD();
 
       // NOTE: See note above about Phage.
       if (class_exists('PhutilErrorTrap')) {
         $trap = new PhutilErrorTrap();
       } else {
         $trap = null;
       }
 
       $spec = self::$descriptorSpec;
-      if ($this->useWindowsFileStreams) {
-        $this->windowsStdoutTempFile = new TempFile();
-        $this->windowsStderrTempFile = new TempFile();
+      if ($is_windows) {
+        $stdout_file = new TempFile();
+        $stderr_file = new TempFile();
+
+        $stdout_handle = fopen($stdout_file, 'wb');
+        if (!$stdout_handle) {
+          throw new Exception(
+            pht(
+              'Unable to open stdout temporary file ("%s") for writing.',
+              $stdout_file));
+        }
+
+        $stderr_handle = fopen($stderr_file, 'wb');
+        if (!$stderr_handle) {
+          throw new Exception(
+            pht(
+              'Unable to open stderr temporary file ("%s") for writing.',
+              $stderr_file));
+        }
 
         $spec = array(
-          0 => self::$descriptorSpec[0],  // stdin
-          1 => fopen($this->windowsStdoutTempFile, 'wb'),  // stdout
-          2 => fopen($this->windowsStderrTempFile, 'wb'),  // stderr
+          0 => self::$descriptorSpec[0],
+          1 => $stdout_handle,
+          2 => $stderr_handle,
         );
-
-        if (!$spec[1] || !$spec[2]) {
-          throw new Exception(pht(
-            'Unable to create temporary files for '.
-            'Windows stdout / stderr streams'));
-        }
       }
 
       $proc = @proc_open(
         $unmasked_command,
         $spec,
         $pipes,
         $cwd,
-        $env);
-
-      if ($this->useWindowsFileStreams) {
-        fclose($spec[1]);
-        fclose($spec[2]);
-        $pipes = array(
-          0 => head($pipes),  // stdin
-          1 => fopen($this->windowsStdoutTempFile, 'rb'),  // stdout
-          2 => fopen($this->windowsStderrTempFile, 'rb'),  // stderr
-        );
-
-        if (!$pipes[1] || !$pipes[2]) {
-          throw new Exception(pht(
-            'Unable to open temporary files for '.
-            'reading Windows stdout / stderr streams'));
-        }
-      }
+        $env,
+        array(
+          'bypass_shell' => true,
+        ));
 
       if ($trap) {
         $err = $trap->getErrorsAsString();
         $trap->destroy();
       } else {
         $err = error_get_last();
       }
 
+      if ($is_windows) {
+        fclose($stdout_handle);
+        fclose($stderr_handle);
+      }
+
       if (!is_resource($proc)) {
-        throw new Exception(
+        // When you run an invalid command on a Linux system, the "proc_open()"
+        // works and then the process (really a "/bin/sh -c ...") exits after
+        // it fails to resolve the command.
+
+        // When you run an invalid command on a Windows system, we bypass the
+        // shell and the "proc_open()" itself fails. Throw a "CommandException"
+        // here for consistency with the Linux behavior in this common failure
+        // case.
+
+        throw new CommandException(
           pht(
-            'Failed to `%s`: %s',
-            'proc_open()',
-            $err));
+            'Call to "proc_open()" to open a subprocess failed: %s',
+            $err),
+          $this->command,
+          1,
+          '',
+          '');
+      }
+
+      if ($is_windows) {
+        $stdout_handle = fopen($stdout_file, 'rb');
+        if (!$stdout_handle) {
+          throw new Exception(
+            pht(
+              'Unable to open stdout temporary file ("%s") for reading.',
+              $stdout_file));
+        }
+
+        $stderr_handle = fopen($stderr_file, 'rb');
+        if (!$stderr_handle) {
+          throw new Exception(
+            pht(
+              'Unable to open stderr temporary file ("%s") for reading.',
+              $stderr_file));
+        }
+
+        $pipes = array(
+          0 => $pipes[0],
+          1 => $stdout_handle,
+          2 => $stderr_handle,
+        );
+
+        $this->windowsStdoutTempFile = $stdout_file;
+        $this->windowsStderrTempFile = $stderr_file;
       }
 
       $this->pipes = $pipes;
       $this->proc  = $proc;
 
       list($stdin, $stdout, $stderr) = $pipes;
 
-      if (!phutil_is_windows()) {
+      if (!$is_windows) {
 
         // On Windows, we redirect process standard output and standard error
-        // through temporary files, and then use stream_select to determine
-        // if there's more data to read.
+        // through temporary files. Files don't block, so we don't need to make
+        // these streams nonblocking.
 
         if ((!stream_set_blocking($stdout, false)) ||
             (!stream_set_blocking($stderr, false)) ||
             (!stream_set_blocking($stdin,  false))) {
           $this->__destruct();
           throw new Exception(pht('Failed to set streams nonblocking.'));
         }
       }
 
       $this->tryToCloseStdin();
 
       return false;
     }
 
     if (!$this->proc) {
       return true;
     }
 
     list($stdin, $stdout, $stderr) = $this->pipes;
 
     while (isset($this->stdin) && $this->stdin->getByteLength()) {
       $write_segment = $this->stdin->getAnyPrefix();
 
       $bytes = fwrite($stdin, $write_segment);
       if ($bytes === false) {
         throw new Exception(pht('Unable to write to stdin!'));
       } else if ($bytes) {
         $this->stdin->removeBytesFromHead($bytes);
       } else {
         // Writes are blocked for now.
         break;
       }
     }
 
     $this->tryToCloseStdin();
 
     // Read status before reading pipes so that we can never miss data that
     // arrives between our last read and the process exiting.
     $status = $this->procGetStatus();
 
     $read_buffer_size = $this->readBufferSize;
 
     $max_stdout_read_bytes = PHP_INT_MAX;
     $max_stderr_read_bytes = PHP_INT_MAX;
     if ($read_buffer_size !== null) {
       $max_stdout_read_bytes = $read_buffer_size - strlen($this->stdout);
       $max_stderr_read_bytes = $read_buffer_size - strlen($this->stderr);
     }
 
     if ($max_stdout_read_bytes > 0) {
       $this->stdout .= $this->readAndDiscard(
         $stdout,
         $this->getStdoutSizeLimit() - strlen($this->stdout),
         'stdout',
         $max_stdout_read_bytes);
     }
 
     if ($max_stderr_read_bytes > 0) {
       $this->stderr .= $this->readAndDiscard(
         $stderr,
         $this->getStderrSizeLimit() - strlen($this->stderr),
         'stderr',
         $max_stderr_read_bytes);
     }
 
     $is_done = false;
     if (!$status['running']) {
       // We may still have unread bytes on stdout or stderr, particularly if
       // this future is being buffered and streamed. If we do, we don't want to
       // consider the subprocess to have exited until we've read everything.
       // See T9724 for context.
       if (feof($stdout) && feof($stderr)) {
         $is_done = true;
       }
     }
 
     if ($is_done) {
-      if ($this->useWindowsFileStreams) {
-        fclose($stdout);
-        fclose($stderr);
-      }
-
       // If the subprocess got nuked with `kill -9`, we get a -1 exitcode.
       // Upgrade this to a slightly more informative value by examining the
       // terminating signal code.
       $err = $status['exitcode'];
       if ($err == -1) {
         if ($status['signaled']) {
           $err = 128 + $status['termsig'];
         }
       }
 
       $this->result = array(
         $err,
         $this->stdout,
         $this->stderr,
       );
       $this->closeProcess();
       return true;
     }
 
     $elapsed = (microtime(true) - $this->start);
 
     if ($this->terminateTimeout && ($elapsed >= $this->terminateTimeout)) {
       if (!$this->didTerminate) {
         $this->killedByTimeout = true;
         $this->sendTerminateSignal();
         return false;
       }
     }
 
     if ($this->killTimeout && ($elapsed >= $this->killTimeout)) {
       $this->killedByTimeout = true;
       $this->resolveKill();
       return true;
     }
 
   }
 
 
   /**
    * @return void
    * @task internal
    */
   public function __destruct() {
     if (!$this->proc) {
       return;
     }
 
     // NOTE: If we try to proc_close() an open process, we hang indefinitely. To
     // avoid this, kill the process explicitly if it's still running.
 
     $status = $this->procGetStatus();
     if ($status['running']) {
       $this->sendTerminateSignal();
       if (!$this->waitForExit(5)) {
         $this->resolveKill();
       }
     } else {
       $this->closeProcess();
     }
   }
 
 
   /**
    * Close and free resources if necessary.
    *
    * @return void
    * @task internal
    */
   private function closeProcess() {
     foreach ($this->pipes as $pipe) {
       if (isset($pipe)) {
         @fclose($pipe);
       }
     }
     $this->pipes = array(null, null, null);
     if ($this->proc) {
       @proc_close($this->proc);
       $this->proc = null;
     }
-    $this->stdin  = null;
+    $this->stdin = null;
+
+    unset($this->windowsStdoutTempFile);
+    unset($this->windowsStderrTempFile);
 
     if ($this->profilerCallID !== null) {
       $profiler = PhutilServiceProfiler::getInstance();
       $profiler->endServiceCall(
         $this->profilerCallID,
         array(
           'err' => $this->result ? idx($this->result, 0) : null,
         ));
       $this->profilerCallID = null;
     }
   }
 
 
   /**
    * Execute `proc_get_status()`, but avoid pitfalls.
    *
    * @return dict Process status.
    * @task internal
    */
   private function procGetStatus() {
     // After the process exits, we only get one chance to read proc_get_status()
     // before it starts returning garbage. Make sure we don't throw away the
     // last good read.
     if ($this->procStatus) {
       if (!$this->procStatus['running']) {
         return $this->procStatus;
       }
     }
     $this->procStatus = proc_get_status($this->proc);
 
     return $this->procStatus;
   }
 
   /**
    * Try to close stdin, if we're done using it. This keeps us from hanging if
    * the process on the other end of the pipe is waiting for EOF.
    *
    * @return void
    * @task internal
    */
   private function tryToCloseStdin() {
     if (!$this->closePipe) {
       // We've been told to keep the pipe open by a call to write(..., true).
       return;
     }
 
     if ($this->stdin->getByteLength()) {
       // We still have bytes to write.
       return;
     }
 
     list($stdin) = $this->pipes;
     if (!$stdin) {
       // We've already closed stdin.
       return;
     }
 
     // There's nothing stopping us from closing stdin, so close it.
 
     @fclose($stdin);
     $this->pipes[0] = null;
   }
 
   public function getDefaultWait() {
     $wait = parent::getDefaultWait();
 
     $next_timeout = $this->getNextTimeout();
     if ($next_timeout) {
       if (!$this->start) {
         $this->start = microtime(true);
       }
       $elapsed = (microtime(true) - $this->start);
       $wait = max(0, min($next_timeout - $elapsed, $wait));
     }
 
     return $wait;
   }
 
   private function getNextTimeout() {
     if ($this->didTerminate) {
       return $this->killTimeout;
     } else {
       return $this->terminateTimeout;
     }
   }
 
   private function sendTerminateSignal() {
     $this->didTerminate = true;
     proc_terminate($this->proc);
     return $this;
   }
 
   private function waitForExit($duration) {
     $start = microtime(true);
 
     while (true) {
       $status = $this->procGetStatus();
       if (!$status['running']) {
         return true;
       }
 
       $waited = (microtime(true) - $start);
       if ($waited > $duration) {
         return false;
       }
     }
   }
 
 }
diff --git a/src/future/exec/__tests__/ExecFutureTestCase.php b/src/future/exec/__tests__/ExecFutureTestCase.php
index 2ce0ad0c..25c5e46a 100644
--- a/src/future/exec/__tests__/ExecFutureTestCase.php
+++ b/src/future/exec/__tests__/ExecFutureTestCase.php
@@ -1,155 +1,168 @@
 <?php
 
 final class ExecFutureTestCase extends PhutilTestCase {
 
   public function testEmptyWrite() {
     // NOTE: This is mostly testing that we don't hang while doing an empty
     // write.
 
-    list($stdout) = id(new ExecFuture('cat'))->write('')->resolvex();
+    list($stdout) = $this->newCat()
+      ->write('')
+      ->resolvex();
 
     $this->assertEqual('', $stdout);
   }
 
+  private function newCat() {
+    $bin = $this->getSupportExecutable('cat');
+    return new ExecFuture('php -f %R', $bin);
+  }
+
+  private function newSleep($duration) {
+    $bin = $this->getSupportExecutable('sleep');
+    return new ExecFuture('php -f %R -- %s', $bin, $duration);
+  }
+
   public function testKeepPipe() {
     // NOTE: This is mostly testing the semantics of $keep_pipe in write().
 
-    list($stdout) = id(new ExecFuture('cat'))
+    list($stdout) = $this->newCat()
       ->write('', true)
       ->start()
       ->write('x', true)
       ->write('y', true)
       ->write('z', false)
       ->resolvex();
 
     $this->assertEqual('xyz', $stdout);
   }
 
   public function testLargeBuffer() {
     // NOTE: This is mostly a coverage test to hit branches where we're still
     // flushing a buffer.
 
     $data = str_repeat('x', 1024 * 1024 * 4);
-    list($stdout) = id(new ExecFuture('cat'))->write($data)->resolvex();
+    list($stdout) = $this->newCat()->write($data)->resolvex();
 
     $this->assertEqual($data, $stdout);
   }
 
   public function testBufferLimit() {
     $data = str_repeat('x', 1024 * 1024);
-    list($stdout) = id(new ExecFuture('cat'))
+    list($stdout) = $this->newCat()
       ->setStdoutSizeLimit(1024)
       ->write($data)
       ->resolvex();
 
     $this->assertEqual(substr($data, 0, 1024), $stdout);
   }
 
   public function testResolveTimeoutTestShouldRunLessThan1Sec() {
     // NOTE: This tests interactions between the resolve() timeout and the
     // ExecFuture timeout, which are similar but not identical.
 
-    $future = id(new ExecFuture('sleep 32000'))->start();
+    $future = $this->newSleep(32000)->start();
     $future->setTimeout(32000);
 
     // We expect this to return in 0.01s.
     $result = $future->resolve(0.01);
     $this->assertEqual($result, null);
 
     // We expect this to now force the time out / kill immediately. If we don't
     // do this, we'll hang when exiting until our subprocess exits (32000
     // seconds!)
     $future->setTimeout(0.01);
     $future->resolve();
   }
 
   public function testTerminateWithoutStart() {
     // We never start this future, but it should be fine to kill a future from
     // any state.
-    $future = new ExecFuture('sleep 1');
+    $future = $this->newSleep(1);
     $future->resolveKill();
 
     $this->assertTrue(true);
   }
 
   public function testTimeoutTestShouldRunLessThan1Sec() {
     // NOTE: This is partly testing that we choose appropriate select wait
     // times; this test should run for significantly less than 1 second.
 
-    $future = new ExecFuture('sleep 32000');
+    $future = $this->newSleep(32000);
     list($err) = $future->setTimeout(0.01)->resolve();
 
     $this->assertTrue($err > 0);
     $this->assertTrue($future->getWasKilledByTimeout());
   }
 
   public function testMultipleTimeoutsTestShouldRunLessThan1Sec() {
     $futures = array();
     for ($ii = 0; $ii < 4; $ii++) {
-      $futures[] = id(new ExecFuture('sleep 32000'))->setTimeout(0.01);
+      $futures[] = $this->newSleep(32000)->setTimeout(0.01);
     }
 
     foreach (new FutureIterator($futures) as $future) {
       list($err) = $future->resolve();
 
       $this->assertTrue($err > 0);
       $this->assertTrue($future->getWasKilledByTimeout());
     }
   }
 
   public function testMultipleResolves() {
     // It should be safe to call resolve(), resolvex(), resolveKill(), etc.,
     // as many times as you want on the same process.
+    $bin = $this->getSupportExecutable('echo');
 
-    $future = new ExecFuture('echo quack');
+    $future = new ExecFuture('php -f %R -- quack', $bin);
     $future->resolve();
     $future->resolvex();
     list($err) = $future->resolveKill();
 
     $this->assertEqual(0, $err);
   }
 
   public function testReadBuffering() {
     $str_len_8 = 'abcdefgh';
     $str_len_4 = 'abcd';
 
     // This is a write/read with no read buffer.
-    $future = new ExecFuture('cat');
+    $future = $this->newCat();
     $future->write($str_len_8);
 
     do {
       $future->isReady();
       list($read) = $future->read();
       if (strlen($read)) {
         break;
       }
     } while (true);
 
     // We expect to get the entire string back in the read.
     $this->assertEqual($str_len_8, $read);
     $future->resolve();
 
 
     // This is a write/read with a read buffer.
-    $future = new ExecFuture('cat');
+    $future = $this->newCat();
     $future->write($str_len_8);
 
     // Set the read buffer size.
     $future->setReadBufferSize(4);
     do {
       $future->isReady();
       list($read) = $future->read();
       if (strlen($read)) {
         break;
       }
     } while (true);
 
     // We expect to get the entire string back in the read.
     $this->assertEqual($str_len_4, $read);
 
     // Remove the limit so we can resolve the future.
     $future->setReadBufferSize(null);
     $future->resolve();
   }
 
 }
diff --git a/src/future/exec/__tests__/ExecPassthruTestCase.php b/src/future/exec/__tests__/ExecPassthruTestCase.php
index f7795fc4..cba1b768 100644
--- a/src/future/exec/__tests__/ExecPassthruTestCase.php
+++ b/src/future/exec/__tests__/ExecPassthruTestCase.php
@@ -1,16 +1,18 @@
 <?php
 
 final class ExecPassthruTestCase extends PhutilTestCase {
 
   public function testExecPassthru() {
     // NOTE: We're limited in what we can do here easily; this process can't
     // read any output from the child process (and it will be sent directly to
     // the terminal, which is undesirable). This makes crafting effective unit
     // tests a fairly involved process.
 
-    $exec = new PhutilExecPassthru('exit');
+    $bin = $this->getSupportExecutable('exit');
+
+    $exec = new PhutilExecPassthru('php -f %R', $bin);
     $err = $exec->execute();
     $this->assertEqual(0, $err);
   }
 
 }
diff --git a/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php b/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php
index 73e66375..3ba41302 100644
--- a/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php
+++ b/src/future/oauth/__tests__/PhutilOAuth1FutureTestCase.php
@@ -1,159 +1,163 @@
 <?php
 
 final class PhutilOAuth1FutureTestCase extends PhutilTestCase {
 
   public function testOAuth1SigningWithOldSpecExmaples() {
 
     // NOTE: These examples are from an old version of the OAuth 1 spec,
     // so they might not be totally accurate.
 
     $uri = 'https://photos.example.net/request_token';
     $future = id(new PhutilOAuth1Future($uri))
       ->setTimestamp(1191242090)
       ->setNonce('hsu94j3884jdopsl')
       ->setConsumerKey('dpf43f3p2l4k3l03')
       ->setConsumerSecret(new PhutilOpaqueEnvelope('kd94hf93k423kf44'))
       ->setSignatureMethod('PLAINTEXT');
 
     $this->assertEqual('kd94hf93k423kf44&', $future->getSignature());
 
 
     $uri = 'http://photos.example.net/photos';
     $data = array(
       'file' => 'vacation.jpg',
       'size' => 'original',
     );
 
     $future = id(new PhutilOAuth1Future($uri, $data))
       ->setMethod('GET')
       ->setTimestamp(1191242096)
       ->setNonce('kllo9940pd9333jh')
       ->setConsumerKey('dpf43f3p2l4k3l03')
       ->setConsumerSecret(new PhutilOpaqueEnvelope('kd94hf93k423kf44'))
       ->setSignatureMethod('HMAC-SHA1')
       ->setToken('nnch734d00sl2jdk')
       ->setTokenSecret('pfkkdhi9sl3r4s00');
 
     $this->assertEqual('tR3+Ty81lMeYAr/Fid0kMTYa/WM=', $future->getSignature());
   }
 
   public function testOAuth1SigningWithTwitterExamples() {
 
     // NOTE: This example is from Twitter.
     // https://dev.twitter.com/docs/auth/creating-signature
 
     $uri = 'https://api.twitter.com/1/statuses/update.json?'.
            'include_entities=true';
     $data = array(
       'status' => 'Hello Ladies + Gentlemen, a signed OAuth request!',
     );
 
     $future = id(new PhutilOAuth1Future($uri, $data))
       ->setMethod('POST')
       ->setConsumerKey('xvz1evFS4wEEPTGEFPHBog')
       ->setConsumerSecret(
         new PhutilOpaqueEnvelope('kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw'))
       ->setNonce('kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg')
       ->setSignatureMethod('HMAC-SHA1')
       ->setTimestamp(1318622958)
       ->setToken('370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb')
       ->setTokenSecret('LswwdoUaIvS8ltyTt5jkRh4J50vUPVVHtR2YPi5kE');
 
     $this->assertEqual('tnnArxj06cWHq44gCs1OSKk/jLY=', $future->getSignature());
   }
 
   public function testOAuth1SigningWithJIRAExamples() {
+    if (!function_exists('openssl_pkey_get_private')) {
+      $this->assertSkipped(
+        pht('Required "openssl" extension is not installed.'));
+    }
 
     // NOTE: This is an emprically example against JIRA v6.0.6, in that the
     // code seems to work when actually authing. It primarily serves as a check
     // of the RSA-SHA1 signature method.
 
 $public_key = <<<EOKEY
 -----BEGIN PUBLIC KEY-----
 MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAz/cLggl8VtHsZAtQudfz
 fN14/xZgtUxA/J10jVwaz30etSiTY1QmeUbL09XKM7NyIL432+AbJkLEJ/EF6NIh
 XkqrtrDvi+48zcSl0zwHthGjESLve9o0i9m1EjEaztnv8EdaNuXkUtYfEMUm9KEk
 iocXTdyLszdtrGOPY1h4qQUrgxO0JY0bBoRa6PqiGe7M/3yvstbW0DGNGvNvLaq7
 k54tPCDKWGKphoEQ6wxd5Hk30LEKn0dqZ5i11ZYal4bfj7UkvjiA5bgAAZmyQ1IV
 CqzMQsPLwAlw/8xyu9EnCE49odmPKn/cbvY5vhoRwDbHDsOuwEPvoFCV9hoXvWhT
 GfWcxDihkgBVDzqHZYgCctTjr+4eZvryBOemPK4FaiEHQ4ZQswX6KT5tW7HcjaQ3
 kGz2pgOstLBGu9EN6t4kmFDLFOzWEYM5CfSuaE54pnfNJNXuTER/a1S8NCnjrVtH
 /h9B2OoNAIUvyLYMhsL7L/0sr8+Sjnoyg+R3rQZZAEJlAiXLtxjD8HGefNPUe8Md
 pEO2GyKD9Z/Vxc5HyIikxqo/+pfjJsOEvbqZg3sHZpTb77+kpCic3CdmXhw8HiXg
 KP9BUSF1iTShnz72zMDDws9t4O3EVFVNLH3Imty8uW1KtSzQbfXO1yNFlZXrn4fy
 54Bwm3hGUO1PNaWg+4F2J8ECAwEAAQ==
 -----END PUBLIC KEY-----
 EOKEY;
 
 $private_key = <<<EOKEY
 -----BEGIN RSA PRIVATE KEY-----
 MIIJJwIBAAKCAgEAz/cLggl8VtHsZAtQudfzfN14/xZgtUxA/J10jVwaz30etSiT
 Y1QmeUbL09XKM7NyIL432+AbJkLEJ/EF6NIhXkqrtrDvi+48zcSl0zwHthGjESLv
 e9o0i9m1EjEaztnv8EdaNuXkUtYfEMUm9KEkiocXTdyLszdtrGOPY1h4qQUrgxO0
 JY0bBoRa6PqiGe7M/3yvstbW0DGNGvNvLaq7k54tPCDKWGKphoEQ6wxd5Hk30LEK
 n0dqZ5i11ZYal4bfj7UkvjiA5bgAAZmyQ1IVCqzMQsPLwAlw/8xyu9EnCE49odmP
 Kn/cbvY5vhoRwDbHDsOuwEPvoFCV9hoXvWhTGfWcxDihkgBVDzqHZYgCctTjr+4e
 ZvryBOemPK4FaiEHQ4ZQswX6KT5tW7HcjaQ3kGz2pgOstLBGu9EN6t4kmFDLFOzW
 EYM5CfSuaE54pnfNJNXuTER/a1S8NCnjrVtH/h9B2OoNAIUvyLYMhsL7L/0sr8+S
 jnoyg+R3rQZZAEJlAiXLtxjD8HGefNPUe8MdpEO2GyKD9Z/Vxc5HyIikxqo/+pfj
 JsOEvbqZg3sHZpTb77+kpCic3CdmXhw8HiXgKP9BUSF1iTShnz72zMDDws9t4O3E
 VFVNLH3Imty8uW1KtSzQbfXO1yNFlZXrn4fy54Bwm3hGUO1PNaWg+4F2J8ECAwEA
 AQKCAgAHV8e2PbOANUVNewDMrw1P2VoOV7HudNTOlpio7RmdPeO5rccWeMArBA7q
 WeAb1zguY8kBIHaU8UKPznjQ8apv898AQlsS68SF122rebEkApdpYXxnORsl3PgB
 vm4d46APMdXDnnZjXmAWbX+kn5P0uDRgcWsVVt2ueo1zioooHaCdrjJsKQFNR5sW
 ItNaaw4d7z8c520KSNWcn//K8v5QhgM+3kGGwWUO9LuuMO+Xw5fu7HFdkl31bnTt
 J7GkrAR0xIaZmNEkS0zkwZKDwgAwMk28BcHJ9AtjXMqoSwg/yNNwRYhCjeUwnc0I
 I0+BI+3/XXVsIHnzhSTmXaF89JQKhEfOHv8asdlcLmqxDJ3EKAfPFXdRbsn5a7AJ
 Jr8ZaTrZzUpK6WBXeyIAsk+8Gc7Pv4KNHynTDirnRHQW6fQKdmxzeD3tlfu4y2NZ
 wWiu3taruxF7O331fvkIZ0s8ba3U/wtNmLwDPbhiF/V+PBjRgWcciWO6GfiZpqrY
 RjS1nKpeLaklb9frdBtoS2FkpRs4zrokQOHLvuDwSPvnwlWy6XyiSGuPTn4VIlmA
 lgi8eCY+dOYk6WFGzCCmeXBvJrjh7votz3atW00DLxDpDosor2e616yZd7TolbK/
 ee7FoFI3rLMjQbWAcEF5Jxmgi/gkqFS8uaUFifrr6wN9dOtcSQKCAQEA9fRTUJM2
 7dRddmC7VDQ4kuYowEh9Drs8R93S5r3GVmlEh9wrkzkkmUYSCEC6ZBzTsavfbYjp
 ruATrsR5cjhFzl7RFodP/Jkpfr1oQdtwOsIF7XY+kMcO129MAn/sCbkc/Jb7tZBo
 oc4XLlIU50dWf33EPZb+h61rxDTLvhd7KnVYlfOpLIfVkG25w5B4P8KNbK86qxyB
 +iOpM7MIXCTguWivChXoEsL/scCIuITowYp7lCz4FAdHpoEm6bwfosl2YhSqfge+
 WgA73FGM9E1QHn6Lw93BmtaDdcCyfD4QTZRKIrVryRIIUNoRwOi6YnyIgSNelUEU
 2k3ymIpoosG0iwKCAQEA2HWBojkX7KkulSWeHApTSGkox8oWYm72BS5SdZtCZltI
 N08dDtOCYUh+868HhNDiiCXBTsnvvF8yRcKLFU3aUBhrJSS8ObO0Topt7rH6xZze
 jLuBUHaJhhem2HBl1hCvec++cgpsxY2GIACQN2jiwm1u8cKIdTVCsHgZlnlMTGCi
 QdAwVIUy/oXnQ2lnd91sCArARSwViUxsfOkwxQJOBiHix8otbR5FZiZRUxGXnXj+
 HFrt2QtFlDTNpTwAYCAjsb1E4VQJB/LCTEmiGXAd4qxDTrEfasSDIOLTuWohz9q0
 nkLXKAHTRiZTT/JW62pahQLG6XcNuDySRSIG/LTCYwKCAQACx+ltPszfMYiA/yT/
 FbwSBSIu0mL/mKRc16g7zaeBcJ1Cv/2KI5pDVWR8zWaOHTlTh/L1xReHT6dJUZVh
 8jrv02ifzZXc8Epk0XVtUTLapzjz72NTtbx4ORzt5k5f6cTnIjnkWqakNbVTY8Ay
 wT68IErou11TYWWXiVVIZ/GPkFYZE/E0vLBwep0gFfEWH3gD45NRPfhGQML3/603
 hX84+XMJNSgzlhrYAqpJE8+h6JPvH/cKGu73dfxfpi3hZE+/WiZ3WFURpXEH07A5
 Tup5/cpMw6QdwREpcq1R9E2w4t1XuR9n3ZlUeLK8sKTy2h+c/i5il6LJuRnmGaKH
 PJNzAoIBAECMMd8FNXwuKyTwtchYz+L88Ns7CRfLTPPYj2BgrxlEyTEtF1Yvfmay
 LqFOJWjWvWaqE44CK8o5fQ1OaRkuQRa3YWQPI031p6PwJb4TNtus3rSKyZIL9xCU
 hv1t7wA5s4oYiAsLzsnOXRu370mGrnAaIAZZ40VIX52uArtbaoQwINKNWYwquD0s
 Av2YNfGJhsiTJCi8b6OktYk+JHvrJwcvHahEQu2SJFHExWWHDnY3+VbNSrX5ZYM/
 h79pOBdyHhLHhP3IiHTlUEldf8gkJdVNVzjlGqBE/3FUEpzs6C5KYqf6+JwGh1EY
 5qkldAP5kAqv/E7sYJv6/Ac/kWPUJ08CggEAYNGB/MxBYjRdJ2F3wk2IE2AgsQRA
 jcXhPnkMSlvWvmyYMDc1GWSbbfeyCbKZN1Lsxlen79Hre3ceJ8r2H4kg+B2Zlt7g
 7sLZCeNA2yl8jLttCkHacramIZ8jDvauS3+2UKL/r/hzpqEwiUkCcI9qLNwDQFxs
 nNXE0ISoMvcPWNJcghoH9zx9EQ5rpLPSImWlc9GjjKkJJ8hjwdp4s0janJUojLRX
 6tdI84ziz6fr/HmFYEDkgttL0EFnSDBG+atth14eLjASloLrlobEcEhwmuvJJ3rS
 xIGlOymzmWzoj2NxVK8H9GLcOG6ftULAMTZgUwayjTLxCLrErlRUVkM7Pg==
 -----END RSA PRIVATE KEY-----
 EOKEY;
 
     $uri = 'http://local.aphront.com:8090/plugins/servlet/oauth/request-token';
     $data = array();
 
     $future = id(new PhutilOAuth1Future($uri, $data))
       ->setConsumerKey('quackquack')
       ->setPrivateKey(new PhutilOpaqueEnvelope($private_key))
       ->setTimestamp('1375984131')
       ->setNonce('iamaduck')
       ->setSignatureMethod('RSA-SHA1');
 
     // The actual signature is 684 bytes and begins "QwigfVxpOm0AKoWJkFRwbyseso
     // VJobhiXpyY0J79Kzki+vwlT4Xz2Tr4vlwDLsra5gJbfdeme4qJ2rE..."
     $this->assertEqual(
       '5e63e65237e2b8078426996d5ef1a706',
       md5($future->getSignature()));
   }
 
 }
diff --git a/src/internationalization/ArcanistUSEnglishTranslation.php b/src/internationalization/ArcanistUSEnglishTranslation.php
index f8d01ee9..bfbc40c5 100644
--- a/src/internationalization/ArcanistUSEnglishTranslation.php
+++ b/src/internationalization/ArcanistUSEnglishTranslation.php
@@ -1,87 +1,92 @@
 <?php
 
 final class ArcanistUSEnglishTranslation extends PhutilTranslation {
 
   public function getLocaleCode() {
     return 'en_US';
   }
 
   protected function getTranslations() {
     return array(
       '%s locally modified path(s) are not included in this revision:' => array(
         'A locally modified path is not included in this revision:',
         'Locally modified paths are not included in this revision:',
       ),
       'These %s path(s) will NOT be committed. Commit this revision '.
       'anyway?' => array(
         'This path will NOT be committed. Commit this revision anyway?',
         'These paths will NOT be committed. Commit this revision anyway?',
       ),
       'Revision includes changes to %s path(s) that do not exist:' => array(
         'Revision includes changes to a path that does not exist:',
         'Revision includes changes to paths that do not exist:',
       ),
 
       'This diff includes %s file(s) which are not valid UTF-8 (they contain '.
       'invalid byte sequences). You can either stop this workflow and fix '.
       'these files, or continue. If you continue, these files will be '.
       'marked as binary.' => array(
         'This diff includes a file which is not valid UTF-8 (it has invalid '.
           'byte sequences). You can either stop this workflow and fix it, or '.
           'continue. If you continue, this file will be marked as binary.',
         'This diff includes files which are not valid UTF-8 (they contain '.
           'invalid byte sequences). You can either stop this workflow and fix '.
           'these files, or continue. If you continue, these files will be '.
           'marked as binary.',
       ),
       '%s AFFECTED FILE(S)' => array('AFFECTED FILE', 'AFFECTED FILES'),
       'Do you want to mark these %s file(s) as binary and continue?' => array(
         'Do you want to mark this file as binary and continue?',
         'Do you want to mark these files as binary and continue?',
       ),
 
       'Do you want to amend these %s change(s) to the current commit?' => array(
         'Do you want to amend this change to the current commit?',
         'Do you want to amend these changes to the current commit?',
       ),
 
       'Do you want to create a new commit with these %s change(s)?' => array(
         'Do you want to create a new commit with this change?',
         'Do you want to create a new commit with these changes?',
       ),
 
       '(To ignore these %s change(s), add them to "%s".)' => array(
         '(To ignore this change, add it to "%2$s".)',
         '(To ignore these changes, add them to "%2$s".)',
       ),
 
       '%s line(s)' => array('line', 'lines'),
 
       '%s assertion(s) passed.' => array(
         '%s assertion passed.',
         '%s assertions passed.',
       ),
 
       'Ignore these %s untracked file(s) and continue?' => array(
         'Ignore this untracked file and continue?',
         'Ignore these untracked files and continue?',
       ),
 
       '%s submodule(s) have uncommitted or untracked changes:' => array(
         'A submodule has uncommitted or untracked changes:',
         'Submodules have uncommitted or untracked changes:',
       ),
 
       'Ignore the changes to these %s submodule(s) and continue?' => array(
         'Ignore the changes to this submodule and continue?',
         'Ignore the changes to these submodules and continue?',
       ),
 
       'These %s commit(s) will be landed:' => array(
         'This commit will be landed:',
         'These commits will be landed:',
       ),
+
+      'Updated %s librarie(s).' => array(
+        'Updated library.',
+        'Updated %s libraries.',
+      ),
     );
   }
 
 }
diff --git a/src/lint/linter/__tests__/ArcanistJSONLintLinterTestCase.php b/src/lint/linter/__tests__/ArcanistJSONLintLinterTestCase.php
deleted file mode 100644
index a81935e5..00000000
--- a/src/lint/linter/__tests__/ArcanistJSONLintLinterTestCase.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-final class ArcanistJSONLintLinterTestCase
-  extends ArcanistExternalLinterTestCase {
-
-  public function testLinter() {
-    $this->executeTestsInDirectory(dirname(__FILE__).'/jsonlint/');
-  }
-
-}
diff --git a/src/lint/linter/__tests__/ArcanistJSONLinterTestCase.php b/src/lint/linter/__tests__/ArcanistJSONLinterTestCase.php
index 5f8c12d4..a221d906 100644
--- a/src/lint/linter/__tests__/ArcanistJSONLinterTestCase.php
+++ b/src/lint/linter/__tests__/ArcanistJSONLinterTestCase.php
@@ -1,9 +1,9 @@
 <?php
 
 final class ArcanistJSONLinterTestCase extends ArcanistLinterTestCase {
 
   public function testLinter() {
-    $this->executeTestsInDirectory(dirname(__FILE__).'/jsonlint/');
+    $this->executeTestsInDirectory(dirname(__FILE__).'/json/');
   }
 
 }
diff --git a/src/lint/linter/__tests__/jsonlint/1.lint-test b/src/lint/linter/__tests__/json/1.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/1.lint-test
rename to src/lint/linter/__tests__/json/1.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/10.lint-test b/src/lint/linter/__tests__/json/10.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/10.lint-test
rename to src/lint/linter/__tests__/json/10.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/11.lint-test b/src/lint/linter/__tests__/json/11.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/11.lint-test
rename to src/lint/linter/__tests__/json/11.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/12.lint-test b/src/lint/linter/__tests__/json/12.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/12.lint-test
rename to src/lint/linter/__tests__/json/12.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/13.lint-test b/src/lint/linter/__tests__/json/13.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/13.lint-test
rename to src/lint/linter/__tests__/json/13.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/14.lint-test b/src/lint/linter/__tests__/json/14.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/14.lint-test
rename to src/lint/linter/__tests__/json/14.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/15.lint-test b/src/lint/linter/__tests__/json/15.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/15.lint-test
rename to src/lint/linter/__tests__/json/15.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/16.lint-test b/src/lint/linter/__tests__/json/16.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/16.lint-test
rename to src/lint/linter/__tests__/json/16.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/17.lint-test b/src/lint/linter/__tests__/json/17.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/17.lint-test
rename to src/lint/linter/__tests__/json/17.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/19.lint-test b/src/lint/linter/__tests__/json/19.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/19.lint-test
rename to src/lint/linter/__tests__/json/19.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/2.lint-test b/src/lint/linter/__tests__/json/2.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/2.lint-test
rename to src/lint/linter/__tests__/json/2.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/20.lint-test b/src/lint/linter/__tests__/json/20.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/20.lint-test
rename to src/lint/linter/__tests__/json/20.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/21.lint-test b/src/lint/linter/__tests__/json/21.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/21.lint-test
rename to src/lint/linter/__tests__/json/21.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/22.lint-test b/src/lint/linter/__tests__/json/22.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/22.lint-test
rename to src/lint/linter/__tests__/json/22.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/23.lint-test b/src/lint/linter/__tests__/json/23.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/23.lint-test
rename to src/lint/linter/__tests__/json/23.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/24.lint-test b/src/lint/linter/__tests__/json/24.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/24.lint-test
rename to src/lint/linter/__tests__/json/24.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/25.lint-test b/src/lint/linter/__tests__/json/25.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/25.lint-test
rename to src/lint/linter/__tests__/json/25.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/26.lint-test b/src/lint/linter/__tests__/json/26.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/26.lint-test
rename to src/lint/linter/__tests__/json/26.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/27.lint-test b/src/lint/linter/__tests__/json/27.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/27.lint-test
rename to src/lint/linter/__tests__/json/27.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/28.lint-test b/src/lint/linter/__tests__/json/28.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/28.lint-test
rename to src/lint/linter/__tests__/json/28.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/29.lint-test b/src/lint/linter/__tests__/json/29.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/29.lint-test
rename to src/lint/linter/__tests__/json/29.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/3.lint-test b/src/lint/linter/__tests__/json/3.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/3.lint-test
rename to src/lint/linter/__tests__/json/3.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/30.lint-test b/src/lint/linter/__tests__/json/30.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/30.lint-test
rename to src/lint/linter/__tests__/json/30.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/31.lint-test b/src/lint/linter/__tests__/json/31.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/31.lint-test
rename to src/lint/linter/__tests__/json/31.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/32.lint-test b/src/lint/linter/__tests__/json/32.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/32.lint-test
rename to src/lint/linter/__tests__/json/32.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/33.lint-test b/src/lint/linter/__tests__/json/33.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/33.lint-test
rename to src/lint/linter/__tests__/json/33.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/34.lint-test b/src/lint/linter/__tests__/json/34.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/34.lint-test
rename to src/lint/linter/__tests__/json/34.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/4.lint-test b/src/lint/linter/__tests__/json/4.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/4.lint-test
rename to src/lint/linter/__tests__/json/4.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/5.lint-test b/src/lint/linter/__tests__/json/5.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/5.lint-test
rename to src/lint/linter/__tests__/json/5.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/6.lint-test b/src/lint/linter/__tests__/json/6.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/6.lint-test
rename to src/lint/linter/__tests__/json/6.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/7.lint-test b/src/lint/linter/__tests__/json/7.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/7.lint-test
rename to src/lint/linter/__tests__/json/7.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/8.lint-test b/src/lint/linter/__tests__/json/8.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/8.lint-test
rename to src/lint/linter/__tests__/json/8.lint-test
diff --git a/src/lint/linter/__tests__/jsonlint/9.lint-test b/src/lint/linter/__tests__/json/9.lint-test
similarity index 100%
rename from src/lint/linter/__tests__/jsonlint/9.lint-test
rename to src/lint/linter/__tests__/json/9.lint-test
diff --git a/src/lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php b/src/lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php
index faf349bf..da3590c4 100644
--- a/src/lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php
+++ b/src/lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php
@@ -1,43 +1,45 @@
 <?php
 
 /**
  * Facilitates implementation of test cases for
  * @{class:ArcanistXHPASTLinterRule}s.
  */
 abstract class ArcanistXHPASTLinterRuleTestCase
   extends ArcanistLinterTestCase {
 
   final protected function getLinter() {
     // Always include this rule so we get good messages if a test includes
     // a syntax error. No normal test should contain syntax errors.
     $syntax_rule = new ArcanistSyntaxErrorXHPASTLinterRule();
 
     $test_rule = $this->getLinterRule();
 
     $rules = array(
       $syntax_rule,
       $test_rule,
     );
 
     return id(new ArcanistXHPASTLinter())
       ->setRules($rules);
   }
 
   /**
    * Returns an instance of the linter rule being tested.
    *
    * @return ArcanistXHPASTLinterRule
    */
   protected function getLinterRule() {
+    $this->assertExecutable('xhpast');
+
     $class = get_class($this);
     $matches = null;
 
     if (!preg_match('/^(\w+XHPASTLinterRule)TestCase$/', $class, $matches) ||
         !is_subclass_of($matches[1], 'ArcanistXHPASTLinterRule')) {
       throw new Exception(pht('Unable to infer linter rule class name.'));
     }
 
     return newv($matches[1], array());
   }
 
 }
diff --git a/src/moduleutils/PhutilLibraryMapBuilder.php b/src/moduleutils/PhutilLibraryMapBuilder.php
index 410ff8fc..c036ed4c 100644
--- a/src/moduleutils/PhutilLibraryMapBuilder.php
+++ b/src/moduleutils/PhutilLibraryMapBuilder.php
@@ -1,514 +1,514 @@
 <?php
 
 /**
  * Build maps of libphutil libraries. libphutil uses the library map to locate
  * and load classes and functions in the library.
  *
  * @task map      Mapping libphutil Libraries
  * @task path     Path Management
  * @task symbol   Symbol Analysis and Caching
  * @task source   Source Management
  */
 final class PhutilLibraryMapBuilder extends Phobject {
 
   private $root;
   private $quiet = true;
   private $subprocessLimit = 8;
 
   private $fileSymbolMap;
   private $librarySymbolMap;
 
   const LIBRARY_MAP_VERSION_KEY   = '__library_version__';
   const LIBRARY_MAP_VERSION       = 2;
 
   const SYMBOL_CACHE_VERSION_KEY  = '__symbol_cache_version__';
   const SYMBOL_CACHE_VERSION      = 11;
 
 
 /* -(  Mapping libphutil Libraries  )---------------------------------------- */
 
   /**
    * Create a new map builder for a library.
    *
    * @param string Path to the library root.
    *
    * @task map
    */
   public function __construct($root) {
     $this->root = $root;
   }
 
   /**
    * Control status output. Use `--quiet` to set this.
    *
    * @param  bool  If true, don't show status output.
    * @return this
    *
    * @task map
    */
   public function setQuiet($quiet) {
     $this->quiet = $quiet;
     return $this;
   }
 
   /**
    * Control subprocess parallelism limit. Use `--limit` to set this.
    *
    * @param  int   Maximum number of subprocesses to run in parallel.
    * @return this
    *
    * @task map
    */
   public function setSubprocessLimit($limit) {
     $this->subprocessLimit = $limit;
     return $this;
   }
 
   /**
    * Get the map of symbols in this library, analyzing the library to build it
    * if necessary.
    *
    * @return map<string, wild> Information about symbols in this library.
    *
    * @task map
    */
   public function buildMap() {
     if ($this->librarySymbolMap === null) {
       $this->analyzeLibrary();
     }
     return $this->librarySymbolMap;
   }
 
 
   /**
    * Get the map of files in this library, analyzing the library to build it
    * if necessary.
    *
    * Returns a map of file paths to information about symbols used and defined
    * in the file.
    *
    * @return map<string, wild> Information about files in this library.
    *
    * @task map
    */
   public function buildFileSymbolMap() {
     if ($this->fileSymbolMap === null) {
       $this->analyzeLibrary();
     }
     return $this->fileSymbolMap;
   }
 
   /**
    * Build and update the library map.
    *
    * @return void
    *
    * @task map
    */
   public function buildAndWriteMap() {
     $library_map = $this->buildMap();
 
     $this->log(pht('Writing map...'));
     $this->writeLibraryMap($library_map);
   }
 
   /**
    * Write a status message to the user, if not running in quiet mode.
    *
    * @param  string  Message to write.
    * @return this
    *
    * @task map
    */
   private function log($message) {
     if (!$this->quiet) {
       @fwrite(STDERR, "%s\n", $message);
     }
     return $this;
   }
 
 
 /* -(  Path Management  )---------------------------------------------------- */
 
   /**
    * Get the path to some file in the library.
    *
    * @param  string  A library-relative path. If omitted, returns the library
    *                 root path.
    * @return string  An absolute path.
    *
    * @task path
    */
   private function getPath($path = '') {
     return $this->root.'/'.$path;
   }
 
   /**
    * Get the path to the symbol cache file.
    *
    * @return string Absolute path to symbol cache.
    *
    * @task path
    */
   private function getPathForSymbolCache() {
     return $this->getPath('.phutil_module_cache');
   }
 
   /**
    * Get the path to the map file.
    *
    * @return string Absolute path to the library map.
    *
    * @task path
    */
   private function getPathForLibraryMap() {
     return $this->getPath('__phutil_library_map__.php');
   }
 
   /**
    * Get the path to the library init file.
    *
    * @return string Absolute path to the library init file
    *
    * @task path
    */
   private function getPathForLibraryInit() {
     return $this->getPath('__phutil_library_init__.php');
   }
 
 
 /* -(  Symbol Analysis and Caching  )---------------------------------------- */
 
   /**
    * Load the library symbol cache, if it exists and is readable and valid.
    *
    * @return dict  Map of content hashes to cache of output from
-   *               `phutil_symbols.php`.
+   *               `extract-symbols.php`.
    *
    * @task symbol
    */
   private function loadSymbolCache() {
     $cache_file = $this->getPathForSymbolCache();
 
     try {
       $cache = Filesystem::readFile($cache_file);
     } catch (Exception $ex) {
       $cache = null;
     }
 
     $symbol_cache = array();
     if ($cache) {
       try {
         $symbol_cache = phutil_json_decode($cache);
       } catch (PhutilJSONParserException $ex) {
         $symbol_cache = array();
       }
     }
 
     $version = idx($symbol_cache, self::SYMBOL_CACHE_VERSION_KEY);
     if ($version != self::SYMBOL_CACHE_VERSION) {
       // Throw away caches from a different version of the library.
       $symbol_cache = array();
     }
     unset($symbol_cache[self::SYMBOL_CACHE_VERSION_KEY]);
 
     return $symbol_cache;
   }
 
   /**
    * Write a symbol map to disk cache.
    *
    * @param  dict  Symbol map of relative paths to symbols.
    * @param  dict  Source map (like @{method:loadSourceFileMap}).
    * @return void
    *
    * @task symbol
    */
   private function writeSymbolCache(array $symbol_map, array $source_map) {
     $cache_file = $this->getPathForSymbolCache();
 
     $cache = array(
       self::SYMBOL_CACHE_VERSION_KEY => self::SYMBOL_CACHE_VERSION,
     );
 
     foreach ($symbol_map as $file => $symbols) {
       $cache[$source_map[$file]] = $symbols;
     }
 
     $json = json_encode($cache);
     try {
       Filesystem::writeFile($cache_file, $json);
     } catch (FilesystemException $ex) {
       $this->log(pht('Unable to save the cache!'));
     }
   }
 
   /**
    * Drop the symbol cache, forcing a clean rebuild.
    *
    * @return this
    *
    * @task symbol
    */
   public function dropSymbolCache() {
     $this->log(pht('Dropping symbol cache...'));
     Filesystem::remove($this->getPathForSymbolCache());
   }
 
   /**
-   * Build a future which returns a `phutil_symbols.php` analysis of a source
+   * Build a future which returns a `extract-symbols.php` analysis of a source
    * file.
    *
    * @param  string  Relative path to the source file to analyze.
    * @return Future  Analysis future.
    *
    * @task symbol
    */
   private function buildSymbolAnalysisFuture($file) {
     $absolute_file = $this->getPath($file);
     $bin = dirname(__FILE__).'/../../support/lib/extract-symbols.php';
 
     return new ExecFuture('php -f %R -- --ugly %R', $bin, $absolute_file);
   }
 
 
 /* -(  Source Management  )-------------------------------------------------- */
 
   /**
    * Build a map of all source files in a library to hashes of their content.
    * Returns an array like this:
    *
    *   array(
    *     'src/parser/ExampleParser.php' => '60b725f10c9c85c70d97880dfe8191b3',
    *     // ...
    *   );
    *
    * @return dict  Map of library-relative paths to content hashes.
    * @task source
    */
   private function loadSourceFileMap() {
     $root = $this->getPath();
 
     $init = $this->getPathForLibraryInit();
     if (!Filesystem::pathExists($init)) {
       throw new Exception(
         pht(
           "Provided path '%s' is not a %s library.",
           $root,
           'phutil'));
     }
 
     $files = id(new FileFinder($root))
       ->withType('f')
       ->withSuffix('php')
       ->excludePath('*/.*')
       ->setGenerateChecksums(true)
       ->find();
 
     $extensions_dir = 'extensions/';
     $extensions_len = strlen($extensions_dir);
 
     $map = array();
     foreach ($files as $file => $hash) {
       $file = Filesystem::readablePath($file, $root);
       $file = ltrim($file, '/');
 
       if (dirname($file) == '.') {
         // We don't permit normal source files at the root level, so just ignore
         // them; they're special library files.
         continue;
       }
 
       // Ignore files in the extensions/ directory.
       if (!strncmp($file, $extensions_dir, $extensions_len)) {
         continue;
       }
 
       // We include also filename in the hash to handle cases when the file is
       // moved without modifying its content.
       $map[$file] = md5($hash.$file);
     }
 
     return $map;
   }
 
   /**
    * Convert the symbol analysis of all the source files in the library into
    * a library map.
    *
    * @param   dict  Symbol analysis of all source files.
    * @return  dict  Library map.
    * @task source
    */
   private function buildLibraryMap(array $symbol_map) {
     $library_map = array(
       'class'     => array(),
       'function'  => array(),
       'xmap'      => array(),
     );
 
     // Detect duplicate symbols within the library.
     foreach ($symbol_map as $file => $info) {
       foreach ($info['have'] as $type => $symbols) {
         foreach ($symbols as $symbol => $declaration) {
           $lib_type = ($type == 'interface') ? 'class' : $type;
           if (!empty($library_map[$lib_type][$symbol])) {
             $prior = $library_map[$lib_type][$symbol];
             throw new Exception(
               pht(
                 "Definition of %s '%s' in file '%s' duplicates prior ".
                 "definition in file '%s'. You can not declare the ".
                 "same symbol twice.",
                 $type,
                 $symbol,
                 $file,
                 $prior));
           }
           $library_map[$lib_type][$symbol] = $file;
         }
       }
       $library_map['xmap'] += $info['xmap'];
     }
 
     // Simplify the common case (one parent) to make the file a little easier
     // to deal with.
     foreach ($library_map['xmap'] as $class => $extends) {
       if (count($extends) == 1) {
         $library_map['xmap'][$class] = reset($extends);
       }
     }
 
     // Sort the map so it is relatively stable across changes.
     foreach ($library_map as $key => $symbols) {
       ksort($symbols);
       $library_map[$key] = $symbols;
     }
     ksort($library_map);
 
     return $library_map;
   }
 
   /**
    * Write a finalized library map.
    *
    * @param  dict Library map structure to write.
    * @return void
    *
    * @task source
    */
   private function writeLibraryMap(array $library_map) {
     $map_file = $this->getPathForLibraryMap();
     $version = self::LIBRARY_MAP_VERSION;
 
     $library_map = array(
       self::LIBRARY_MAP_VERSION_KEY => $version,
     ) + $library_map;
 
     $library_map = phutil_var_export($library_map);
     $at = '@';
 
     $source_file = <<<EOPHP
 <?php
 
 /**
  * This file is automatically generated. Use 'arc liberate' to rebuild it.
  *
  * {$at}generated
  * {$at}phutil-library-version {$version}
  */
 phutil_register_library_map({$library_map});
 
 EOPHP;
 
     Filesystem::writeFile($map_file, $source_file);
   }
 
 
   /**
    * Analyze the library, generating the file and symbol maps.
    *
    * @return void
    */
   private function analyzeLibrary() {
     // Identify all the ".php" source files in the library.
     $this->log(pht('Finding source files...'));
     $source_map = $this->loadSourceFileMap();
     $this->log(
       pht('Found %s files.', new PhutilNumber(count($source_map))));
 
     // Load the symbol cache with existing parsed symbols. This allows us
     // to remap libraries quickly by analyzing only changed files.
     $this->log(pht('Loading symbol cache...'));
     $symbol_cache = $this->loadSymbolCache();
 
     // If the XHPAST binary is not up-to-date, build it now. Otherwise,
-    // `phutil_symbols.php` will attempt to build the binary and will fail
+    // `extract-symbols.php` will attempt to build the binary and will fail
     // miserably because it will be trying to build the same file multiple
     // times in parallel.
     if (!PhutilXHPASTBinary::isAvailable()) {
       PhutilXHPASTBinary::build();
     }
 
     // Build out the symbol analysis for all the files in the library. For
     // each file, check if it's in cache. If we miss in the cache, do a fresh
     // analysis.
     $symbol_map = array();
     $futures = array();
     foreach ($source_map as $file => $hash) {
       if (!empty($symbol_cache[$hash])) {
         $symbol_map[$file] = $symbol_cache[$hash];
         continue;
       }
       $futures[$file] = $this->buildSymbolAnalysisFuture($file);
     }
     $this->log(
       pht('Found %s files in cache.', new PhutilNumber(count($symbol_map))));
 
     // Run the analyzer on any files which need analysis.
     if ($futures) {
       $limit = $this->subprocessLimit;
 
       $this->log(
         pht(
           'Analyzing %s file(s) with %s subprocess(es)...',
           phutil_count($futures),
           new PhutilNumber($limit)));
 
       $progress = new PhutilConsoleProgressBar();
       if ($this->quiet) {
         $progress->setQuiet(true);
       }
       $progress->setTotal(count($futures));
 
       $futures = id(new FutureIterator($futures))
         ->limit($limit);
       foreach ($futures as $file => $future) {
         $result = $future->resolveJSON();
         if (empty($result['error'])) {
           $symbol_map[$file] = $result;
         } else {
           $progress->done(false);
           throw new XHPASTSyntaxErrorException(
             $result['line'],
             $file.': '.$result['error']);
         }
         $progress->update(1);
       }
       $progress->done();
     }
 
     $this->fileSymbolMap = $symbol_map;
 
     // We're done building the cache, so write it out immediately. Note that
     // we've only retained entries for files we found, so this implicitly cleans
     // out old cache entries.
     $this->writeSymbolCache($symbol_map, $source_map);
 
     // Our map is up to date, so either show it on stdout or write it to disk.
     $this->log(pht('Building library map...'));
 
     $this->librarySymbolMap = $this->buildLibraryMap($symbol_map);
   }
 
 
 }
diff --git a/src/parser/PhutilEditorConfig.php b/src/parser/PhutilEditorConfig.php
index a03d2bf6..d2bf93a3 100644
--- a/src/parser/PhutilEditorConfig.php
+++ b/src/parser/PhutilEditorConfig.php
@@ -1,195 +1,201 @@
 <?php
 
 /**
  * Parser for [[http://editorconfig.org/ | EditorConfig]] files.
  */
 final class PhutilEditorConfig extends Phobject {
 
   const CHARSET             = 'charset';
   const END_OF_LINE         = 'end_of_line';
   const INDENT_SIZE         = 'indent_size';
   const INDENT_STYLE        = 'indent_style';
   const FINAL_NEWLINE       = 'insert_final_newline';
   const LINE_LENGTH         = 'max_line_length';
   const TAB_WIDTH           = 'tab_width';
   const TRAILING_WHITESPACE = 'trim_trailing_whitespace';
 
   /**
    * Valid properties.
    *
    * See http://editorconfig.org/#file-format-details.
    */
   private static $knownProperties = array(
     self::CHARSET => array(
       'latin1',
       'utf-8',
       'utf-8-bom',
       'utf-16be',
       'utf-16le',
     ),
     self::END_OF_LINE => array('lf', 'cr', 'crlf'),
     self::INDENT_SIZE => 'int|string',
     self::INDENT_STYLE => array('space', 'tab'),
     self::FINAL_NEWLINE => 'bool',
     self::LINE_LENGTH => 'int',
     self::TAB_WIDTH => 'int',
     self::TRAILING_WHITESPACE => 'bool',
   );
 
   private $root;
 
   /**
    * Constructor.
    *
    * @param string  The root directory.
    */
   public function __construct($root) {
     $this->root = $root;
   }
 
   /**
    * Get the specified EditorConfig property for the specified path.
    *
    * @param  string
    * @param  string
    * @return wild
    */
   public function getProperty($path, $key) {
     if (!idx(self::$knownProperties, $key)) {
       throw new InvalidArgumentException(pht('Invalid EditorConfig property.'));
     }
 
     $props = $this->getProperties($path);
 
     switch ($key) {
       case self::INDENT_SIZE:
         if (idx($props, self::INDENT_SIZE) === null &&
             idx($props, self::INDENT_STYLE) === 'tab') {
           return 'tab';
         } else if (idx($props, self::INDENT_SIZE) === 'tab' &&
                    idx($props, self::TAB_WIDTH) === null) {
           return idx($props, self::TAB_WIDTH);
         }
         break;
 
       case self::TAB_WIDTH:
         if (idx($props, self::TAB_WIDTH) === null &&
             idx($props, self::INDENT_SIZE) !== null &&
             idx($props, self::INDENT_SIZE) !== 'tab') {
           return idx($props, self::INDENT_SIZE);
         }
         break;
     }
 
     return idx($props, $key);
   }
 
   /**
    * Get the EditorConfig properties for the specified path.
    *
    * Returns a map containing all of the EditorConfig properties which apply
    * to the specified path. The following rules are applied when processing
    * EditorConfig files:
    *
    * - If a glob does not contain `/`, it can match a path in any subdirectory.
    * - If the first character of a glob is `/`, it will only match files in the
    *   same directory as the `.editorconfig` file.
    * - Properties and values are case-insensitive.
    * - Unknown properties will be silently ignored.
    * - Values are not validated against the specification (this may change in
    *   the future).
    * - Invalid glob patterns will be silently ignored.
    *
    * @param  string
    * @return map<string, wild>
    */
   public function getProperties($path) {
     $configs = $this->getEditorConfigs($path);
     $matches = array();
 
+    // Normalize directory separators to "/". The ".editorconfig" standard
+    // uses only "/" as a directory separator, not "\".
+    $path = str_replace(DIRECTORY_SEPARATOR, '/', $path);
+
     foreach ($configs as $config) {
       list($path_prefix, $editorconfig) = $config;
 
+      // Normalize path separators, as above.
+      $path_prefix = str_replace(DIRECTORY_SEPARATOR, '/', $path_prefix);
+
       foreach ($editorconfig as $glob => $properties) {
         if (!$glob) {
           continue;
         }
 
         if (strpos($glob, '/') === false) {
           $glob = '**/'.$glob;
         } else if (strncmp($glob, '/', 0)) {
           $glob = substr($glob, 1);
         }
 
         $glob = $path_prefix.'/'.$glob;
         try {
           if (!phutil_fnmatch($glob, $path)) {
             continue;
           }
         } catch (Exception $ex) {
           // Invalid glob pattern... ignore it.
           continue;
         }
 
         foreach ($properties as $property => $value) {
           $property = strtolower($property);
 
           if (!idx(self::$knownProperties, $property)) {
             // Unknown property... ignore it.
             continue;
           }
 
           if (is_string($value)) {
             $value = strtolower($value);
           }
           if ($value === '') {
             $value = null;
           }
           $matches[$property] = $value;
         }
       }
     }
 
     return $matches;
   }
 
   /**
    * Returns the EditorConfig files which affect the specified path.
    *
    * Find and parse all `.editorconfig` files between the specified path and
    * the root directory. The results are returned in the same order that they
    * should be matched.
    *
    * return list<pair<string, map>>
    */
   private function getEditorConfigs($path) {
-    $configs    = array();
-    $found_root = false;
-    $root       = $this->root;
+    $configs = array();
 
-    do {
-      $path = dirname($path);
+    $found_root = false;
+    $paths = Filesystem::walkToRoot($path, $this->root);
+    foreach ($paths as $path) {
       $file = $path.'/.editorconfig';
 
       if (!Filesystem::pathExists($file)) {
         continue;
       }
 
       $contents = Filesystem::readFile($file);
       $config = phutil_ini_decode($contents);
 
       if (idx($config, 'root') === true) {
         $found_root = true;
       }
       unset($config['root']);
       array_unshift($configs, array($path, $config));
 
       if ($found_root) {
         break;
       }
-    } while ($path != $root && Filesystem::isDescendant($path, $root));
+    }
 
     return $configs;
   }
 
 }
diff --git a/src/parser/PhutilJSONParser.php b/src/parser/PhutilJSONParser.php
index d3b5aef5..3b06f4b2 100644
--- a/src/parser/PhutilJSONParser.php
+++ b/src/parser/PhutilJSONParser.php
@@ -1,64 +1,64 @@
 <?php
 
 /**
  * A JSON parser.
  *
  * @phutil-external-symbol class JsonLintJsonParser
  * @phutil-external-symbol class JsonLintParsingException
  */
 final class PhutilJSONParser extends Phobject {
 
   private $allowDuplicateKeys = false;
 
   public function setAllowDuplicateKeys($allow_duplicate_keys) {
     $this->allowDuplicateKeys = $allow_duplicate_keys;
     return $this;
   }
 
   public function parse($json) {
-    $jsonlint_root = phutil_get_library_root('arcanist');
-    $jsonlint_root = $jsonlint_root.'/../externals/jsonlint';
+    $arcanist_root = phutil_get_library_root('arcanist');
+    $jsonlint_root = $arcanist_root.'/../externals/jsonlint';
 
     require_once $jsonlint_root.'/src/Seld/JsonLint/JsonParser.php';
     require_once $jsonlint_root.'/src/Seld/JsonLint/Lexer.php';
     require_once $jsonlint_root.'/src/Seld/JsonLint/ParsingException.php';
     require_once $jsonlint_root.'/src/Seld/JsonLint/Undefined.php';
 
     $parser = new JsonLintJsonParser();
     try {
       $output = $parser->parse($json, $this->getFlags());
     } catch (JsonLintParsingException $ex) {
       $details = $ex->getDetails();
       $message = preg_replace("/^Parse error .*\\^\n/s", '', $ex->getMessage());
 
       throw new PhutilJSONParserException(
           $message,
           idx(idx($details, 'loc', array()), 'last_line'),
           idx(idx($details, 'loc', array()), 'last_column'),
           idx($details, 'token'),
           idx($details, 'expected'));
     }
 
     if (!is_array($output)) {
       throw new PhutilJSONParserException(
         pht(
           '%s is not a valid JSON object.',
           PhutilReadableSerializer::printShort($json)));
     }
 
     return $output;
   }
 
   private function getFlags() {
     $flags = JsonLintJsonParser::PARSE_TO_ASSOC;
 
     if ($this->allowDuplicateKeys) {
       $flags |= JsonLintJsonParser::ALLOW_DUPLICATE_KEYS;
     } else {
       $flags |= JsonLintJsonParser::DETECT_KEY_CONFLICTS;
     }
 
     return $flags;
   }
 
 }
diff --git a/src/phage/__tests__/PhageAgentTestCase.php b/src/phage/__tests__/PhageAgentTestCase.php
index 4973081a..1e0c43b6 100644
--- a/src/phage/__tests__/PhageAgentTestCase.php
+++ b/src/phage/__tests__/PhageAgentTestCase.php
@@ -1,49 +1,53 @@
 <?php
 
 final class PhageAgentTestCase extends PhutilTestCase {
 
   public function testPhagePHPAgent() {
+    if (phutil_is_windows()) {
+      $this->assertSkipped(pht('Phage does not target Windows.'));
+    }
+
     return $this->runBootloaderTests(new PhagePHPAgentBootloader());
   }
 
   private function runBootloaderTests(PhageAgentBootloader $boot) {
     $name = get_class($boot);
 
     $exec = new ExecFuture('%C', $boot->getBootCommand());
     $exec->write($boot->getBootSequence(), $keep_open = true);
 
     $exec_channel = new PhutilExecChannel($exec);
     $agent = new PhutilJSONProtocolChannel($exec_channel);
 
     $agent->write(
       array(
         'type'    => 'EXEC',
         'key'     => 1,
         'command' => 'echo phage',
         'timeout' => null,
       ));
 
     $this->agentExpect(
       $agent,
       array(
         'type'    => 'RSLV',
         'key'     => 1,
         'err'     => 0,
         'stdout'  => "phage\n",
         'stderr'  => '',
         'timeout' => false,
       ),
       pht("'%s' for %s", 'echo phage', $name));
 
     $agent->write(
       array(
         'type'    => 'EXIT',
       ));
   }
 
   private function agentExpect(PhutilChannel $agent, $expect, $what) {
     $message = $agent->waitForMessage();
     $this->assertEqual($expect, $message, $what);
   }
 
 }
diff --git a/src/symbols/PhutilClassMapQuery.php b/src/symbols/PhutilClassMapQuery.php
index 738b14c5..4b947a61 100644
--- a/src/symbols/PhutilClassMapQuery.php
+++ b/src/symbols/PhutilClassMapQuery.php
@@ -1,332 +1,338 @@
 <?php
 
 /**
  * Load a map of concrete subclasses of some abstract parent class.
  *
  * libphutil is extensively modular through runtime introspection of class
  * maps. This method makes querying class maps easier.
  *
  * There are several common patterns used with modular class maps:
  *
  *   - A `getUniqueKey()` method which returns a unique scalar key identifying
  *     the class.
  *   - An `expandVariants()` method which potentially returns multiple
  *     instances of the class with different configurations.
  *   - A `getSortName()` method which sorts results.
  *   - Caching of the map.
  *
  * This class provides support for these mechanisms.
  *
  * Using the unique key mechanism with @{method:setUniqueMethod} allows you to
  * use a more human-readable, storage-friendly key to identify objects, allows
  * classes to be freely renamed, and enables variant expansion.
  *
  * Using the expansion mechanism with @{method:setExpandMethod} allows you to
  * have multiple similar modular instances, or configuration-driven instances.
  *
  * Even if they have no immediate need for either mechanism, class maps should
  * generally provide unique keys in their initial design so they are more
  * flexible later on. Adding unique keys later can require database migrations,
  * while adding an expansion mechanism is trivial if a class map already has
  * unique keys.
  *
  * This class automatically caches class maps and does not need to be wrapped
  * in caching logic.
  *
  * @task config Configuring the Query
  * @task exec Executing the Query
  * @task cache Managing the Map Cache
  */
 final class PhutilClassMapQuery extends Phobject {
 
   private $ancestorClass;
   private $expandMethod;
   private $filterMethod;
   private $filterNull = false;
   private $uniqueMethod;
   private $sortMethod;
+  private $continueOnFailure;
 
   // NOTE: If you add more configurable properties here, make sure that
   // cache key construction in getCacheKey() is updated properly.
 
   private static $cache = array();
 
 
 /* -(  Configuring the Query  )---------------------------------------------- */
 
 
   /**
    * Set the ancestor class or interface name to load the concrete descendants
    * of.
    *
    * @param string Ancestor class or interface name.
    * @return this
    * @task config
    */
   public function setAncestorClass($class) {
     $this->ancestorClass = $class;
     return $this;
   }
 
 
   /**
    * Provide a method to select a unique key for each instance.
    *
    * If you provide a method here, the map will be keyed with these values,
    * instead of with class names. Exceptions will be raised if entries are
    * not unique.
    *
    * You must provide a method here to use @{method:setExpandMethod}.
    *
    * @param string  Name of the unique key method.
    * @param bool    If true, then classes which return `null` will be filtered
    *                from the results.
    * @return this
    * @task config
    */
   public function setUniqueMethod($unique_method, $filter_null = false) {
     $this->uniqueMethod = $unique_method;
     $this->filterNull   = $filter_null;
     return $this;
   }
 
 
   /**
    * Provide a method to expand each concrete subclass into available instances.
    *
    * With some class maps, each class is allowed to provide multiple entries
    * in the map by returning alternatives from some method with a default
    * implementation like this:
    *
    *   public function generateVariants() {
    *     return array($this);
    *   }
    *
    * For example, a "color" class may really generate and configure several
    * instances in the final class map:
    *
    *   public function generateVariants() {
    *     return array(
    *       self::newColor('red'),
    *       self::newColor('green'),
    *       self::newColor('blue'),
    *     );
    *   }
    *
    * This allows multiple entires in the final map to share an entire
    * implementation, rather than requiring that they each have their own unique
    * subclass.
    *
    * This pattern is most useful if several variants are nearly identical (so
    * the stub subclasses would be essentially empty) or the available variants
    * are driven by configuration.
    *
    * If a class map uses this pattern, it must also provide a unique key for
    * each instance with @{method:setUniqueMethod}.
    *
    * @param string Name of the expansion method.
    * @return this
    * @task config
    */
   public function setExpandMethod($expand_method) {
     $this->expandMethod = $expand_method;
     return $this;
   }
 
 
   /**
    * Provide a method to sort the final map.
    *
    * The map will be sorted using @{function:msort} and passing this method
    * name.
    *
    * @param string Name of the sorting method.
    * @return this
    * @task config
    */
   public function setSortMethod($sort_method) {
     $this->sortMethod = $sort_method;
     return $this;
   }
 
 
   /**
    * Provide a method to filter the map.
    *
    * @param string Name of the filtering method.
    * @return this
    * @task config
    */
   public function setFilterMethod($filter_method) {
     $this->filterMethod = $filter_method;
     return $this;
   }
 
+  public function setContinueOnFailure($continue) {
+    $this->continueOnFailure = $continue;
+    return $this;
+  }
 
 /* -(  Executing the Query  )------------------------------------------------ */
 
 
   /**
    * Execute the query as configured.
    *
    * @return map<string, object> Realized class map.
    * @task exec
    */
   public function execute() {
     $cache_key = $this->getCacheKey();
 
     if (!isset(self::$cache[$cache_key])) {
       self::$cache[$cache_key] = $this->loadMap();
     }
 
     return self::$cache[$cache_key];
   }
 
 
   /**
    * Delete all class map caches.
    *
    * @return void
    * @task exec
    */
   public static function deleteCaches() {
     self::$cache = array();
   }
 
 
   /**
    * Generate the core query results.
    *
    * This method is used to fill the cache.
    *
    * @return map<string, object> Realized class map.
    * @task exec
    */
   private function loadMap() {
     $ancestor = $this->ancestorClass;
     if (!strlen($ancestor)) {
       throw new PhutilInvalidStateException('setAncestorClass');
     }
 
     if (!class_exists($ancestor) && !interface_exists($ancestor)) {
       throw new Exception(
         pht(
           'Trying to execute a class map query for descendants of class '.
           '"%s", but no such class or interface exists.',
           $ancestor));
     }
 
     $expand = $this->expandMethod;
     $filter = $this->filterMethod;
     $unique = $this->uniqueMethod;
     $sort = $this->sortMethod;
 
     if (strlen($expand)) {
       if (!strlen($unique)) {
         throw new Exception(
           pht(
             'Trying to execute a class map query for descendants of class '.
             '"%s", but the query specifies an "expand method" ("%s") without '.
             'specifying a "unique method". Class maps which support expansion '.
             'must have unique keys.',
             $ancestor,
             $expand));
       }
     }
 
     $objects = id(new PhutilSymbolLoader())
       ->setAncestorClass($ancestor)
+      ->setContinueOnFailure($this->continueOnFailure)
       ->loadObjects();
 
     // Apply the "expand" mechanism, if it is configured.
     if (strlen($expand)) {
       $list = array();
       foreach ($objects as $object) {
         foreach (call_user_func(array($object, $expand)) as $instance) {
           $list[] = $instance;
         }
       }
     } else {
       $list = $objects;
     }
 
     // Apply the "unique" mechanism, if it is configured.
     if (strlen($unique)) {
       $map = array();
       foreach ($list as $object) {
         $key = call_user_func(array($object, $unique));
 
         if ($key === null && $this->filterNull) {
           continue;
         }
 
         if (empty($map[$key])) {
           $map[$key] = $object;
           continue;
         }
 
         throw new Exception(
           pht(
             'Two objects (of classes "%s" and "%s", descendants of ancestor '.
             'class "%s") returned the same key from "%s" ("%s"), but each '.
             'object in this class map must be identified by a unique key.',
             get_class($object),
             get_class($map[$key]),
             $ancestor,
             $unique.'()',
             $key));
       }
     } else {
       $map = $list;
     }
 
     // Apply the "filter" mechanism, if it is configured.
     if (strlen($filter)) {
       $map = mfilter($map, $filter);
     }
 
     // Apply the "sort" mechanism, if it is configured.
     if (strlen($sort)) {
       if ($map) {
         // The "sort" method may return scalars (which we want to sort with
         // "msort()"), or may return PhutilSortVector objects (which we want
         // to sort with "msortv()").
         $item = call_user_func(array(head($map), $sort));
 
         // Since we may be early in the stack, use a string to avoid triggering
         // autoload in old versions of PHP.
         $vector_class = 'PhutilSortVector';
         if ($item instanceof $vector_class) {
           $map = msortv($map, $sort);
         } else {
           $map = msort($map, $sort);
         }
       }
     }
 
     return $map;
   }
 
 
 /* -(  Managing the Map Cache  )--------------------------------------------- */
 
 
   /**
    * Return a cache key for this query.
    *
    * @return string Cache key.
    * @task cache
    */
   public function getCacheKey() {
     $parts = array(
       $this->ancestorClass,
       $this->uniqueMethod,
       $this->filterNull,
       $this->expandMethod,
       $this->filterMethod,
       $this->sortMethod,
     );
     return implode(':', $parts);
   }
 
 }
diff --git a/src/symbols/PhutilSymbolLoader.php b/src/symbols/PhutilSymbolLoader.php
index cdf23369..32c7a042 100644
--- a/src/symbols/PhutilSymbolLoader.php
+++ b/src/symbols/PhutilSymbolLoader.php
@@ -1,413 +1,455 @@
 <?php
 
 /**
  * Query and load Phutil classes, interfaces and functions.
  *
  * `PhutilSymbolLoader` is a query object which selects symbols which satisfy
  * certain criteria, and optionally loads them. For instance, to load all
  * classes in a library:
  *
  * ```lang=php
  * $symbols = id(new PhutilSymbolLoader())
  *   ->setType('class')
  *   ->setLibrary('example')
  *   ->selectAndLoadSymbols();
  * ```
  *
  * When you execute the loading query, it returns a dictionary of matching
  * symbols:
  *
  * ```lang=php
  * array(
  *   'class$Example' => array(
  *     'type'    => 'class',
  *     'name'    => 'Example',
  *     'library' => 'libexample',
  *     'where'   => 'examples/example.php',
  *   ),
  *   // ... more ...
  * );
  * ```
  *
  * The **library** and **where** keys show where the symbol is defined. The
  * **type** and **name** keys identify the symbol itself.
  *
  * NOTE: This class must not use libphutil functions, including @{function:id}
  * and @{function:idx}.
  *
  * @task config   Configuring the Query
  * @task load     Loading Symbols
  * @task internal Internals
  */
 final class PhutilSymbolLoader {
 
   private $type;
   private $library;
   private $base;
   private $name;
   private $concrete;
   private $pathPrefix;
 
   private $suppressLoad;
+  private $continueOnFailure;
 
 
   /**
    * Select the type of symbol to load, either `class`, `function` or
    * `interface`.
    *
    * @param string  Type of symbol to load.
    * @return this
    *
    * @task config
    */
   public function setType($type) {
     $this->type = $type;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to a specific library; only symbols from this
    * library will be loaded.
    *
    * @param string Library name.
    * @return this
    *
    * @task config
    */
   public function setLibrary($library) {
     // Validate the library name; this throws if the library in not loaded.
     $bootloader = PhutilBootloader::getInstance();
     $bootloader->getLibraryRoot($library);
 
     $this->library = $library;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to a specific path prefix; only symbols defined
    * in files below that path will be selected.
    *
    * @param string Path relative to library root, like "apps/cheese/".
    * @return this
    *
    * @task config
    */
   public function setPathPrefix($path) {
     $this->pathPrefix = str_replace(DIRECTORY_SEPARATOR, '/', $path);
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to a single symbol name, e.g. a specific class
    * or function name.
    *
    * @param string Symbol name.
    * @return this
    *
    * @task config
    */
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to only descendants of some class. This will
    * strictly select descendants, the base class will not be selected. This
    * implies loading only classes.
    *
    * @param string Base class name.
    * @return this
    *
    * @task config
    */
   public function setAncestorClass($base) {
     $this->base = $base;
     return $this;
   }
 
 
   /**
    * Restrict the symbol query to only concrete symbols; this will filter out
    * abstract classes.
    *
    * NOTE: This currently causes class symbols to load, even if you run
    * @{method:selectSymbolsWithoutLoading}.
    *
    * @param bool True if the query should load only concrete symbols.
    * @return this
    *
    * @task config
    */
   public function setConcreteOnly($concrete) {
     $this->concrete = $concrete;
     return $this;
   }
 
+  public function setContinueOnFailure($continue) {
+    $this->continueOnFailure = $continue;
+    return $this;
+  }
 
 /* -(  Load  )--------------------------------------------------------------- */
 
 
   /**
    * Execute the query and select matching symbols, then load them so they can
    * be used.
    *
    * @return dict A dictionary of matching symbols. See top-level class
    *              documentation for details. These symbols will be loaded
    *              and available.
    *
    * @task load
    */
   public function selectAndLoadSymbols() {
     $map = array();
 
     $bootloader = PhutilBootloader::getInstance();
 
     if ($this->library) {
       $libraries = array($this->library);
     } else {
       $libraries = $bootloader->getAllLibraries();
     }
 
     if ($this->type) {
       $types = array($this->type);
     } else {
       $types = array(
         'class',
         'function',
       );
     }
 
     $names = null;
     if ($this->base) {
       $names = $this->selectDescendantsOf(
         $bootloader->getClassTree(),
         $this->base);
     }
 
     $symbols = array();
     foreach ($libraries as $library) {
       $map = $bootloader->getLibraryMap($library);
       foreach ($types as $type) {
         if ($type == 'interface') {
           $lookup_map = $map['class'];
         } else {
           $lookup_map = $map[$type];
         }
 
         // As an optimization, we filter the list of candidate symbols in
         // several passes, applying a name-based filter first if possible since
         // it is highly selective and guaranteed to match at most one symbol.
         // This is the common case and we land here through `__autoload()` so
         // it's worthwhile to micro-optimize a bit because this code path is
         // very hot and we save 5-10ms per page for a very moderate increase in
         // complexity.
 
         if ($this->name) {
           // If we have a name filter, just pick the matching name out if it
           // exists.
           if (isset($lookup_map[$this->name])) {
             $filtered_map = array(
               $this->name => $lookup_map[$this->name],
             );
           } else {
             $filtered_map = array();
           }
         } else if ($names !== null) {
           $filtered_map = array();
           foreach ($names as $name => $ignored) {
             if (isset($lookup_map[$name])) {
               $filtered_map[$name] = $lookup_map[$name];
             }
           }
         } else {
           // Otherwise, start with everything.
           $filtered_map = $lookup_map;
         }
 
         if ($this->pathPrefix) {
           $len = strlen($this->pathPrefix);
           foreach ($filtered_map as $name => $where) {
             if (strncmp($where, $this->pathPrefix, $len) !== 0) {
               unset($filtered_map[$name]);
             }
           }
         }
 
         foreach ($filtered_map as $name => $where) {
           $symbols[$type.'$'.$name] = array(
             'type'        => $type,
             'name'        => $name,
             'library'     => $library,
             'where'       => $where,
           );
         }
       }
     }
 
     if (!$this->suppressLoad) {
+      // Loading a class may trigger the autoloader to load more classes
+      // (usually, the parent class), so we need to keep track of whether we
+      // are currently loading in "continue on failure" mode. Otherwise, we'll
+      // fail anyway if we fail to load a parent class.
+
+      // The driving use case for the "continue on failure" mode is to let
+      // "arc liberate" run so it can rebuild the library map, even if you have
+      // made changes to Workflow or Config classes which it must load before
+      // it can operate. If we don't let it continue on failure, it is very
+      // difficult to remove or move Workflows.
+
+      static $continue_depth = 0;
+      if ($this->continueOnFailure) {
+        $continue_depth++;
+      }
+
       $caught = null;
-      foreach ($symbols as $symbol) {
+      foreach ($symbols as $key => $symbol) {
         try {
           $this->loadSymbol($symbol);
         } catch (Exception $ex) {
+          // If we failed to load this symbol, remove it from the results.
+          // Otherwise, we may fatal below when trying to reflect it.
+          unset($symbols[$key]);
+
           $caught = $ex;
         }
       }
+
+      $should_continue = ($continue_depth > 0);
+
+      if ($this->continueOnFailure) {
+        $continue_depth--;
+      }
+
       if ($caught) {
         // NOTE: We try to load everything even if we fail to load something,
         // primarily to make it possible to remove functions from a libphutil
         // library without breaking library startup.
-        throw $caught;
+        if ($should_continue) {
+          // We may not have `pht()` yet.
+          fprintf(
+            STDERR,
+            "%s: %s\n",
+            'IGNORING CLASS LOAD FAILURE',
+            $caught->getMessage());
+        } else {
+          throw $caught;
+        }
       }
     }
 
 
     if ($this->concrete) {
       // Remove 'abstract' classes.
       foreach ($symbols as $key => $symbol) {
         if ($symbol['type'] == 'class') {
           $reflection = new ReflectionClass($symbol['name']);
           if ($reflection->isAbstract()) {
             unset($symbols[$key]);
           }
         }
       }
     }
 
     return $symbols;
   }
 
 
   /**
    * Execute the query and select matching symbols, but do not load them. This
    * will perform slightly better if you are only interested in the existence
    * of the symbols and don't plan to use them; otherwise, use
    * @{method:selectAndLoadSymbols}.
    *
    * @return dict A dictionary of matching symbols. See top-level class
    *              documentation for details.
    *
    * @task load
    */
   public function selectSymbolsWithoutLoading() {
     $this->suppressLoad = true;
     $result = $this->selectAndLoadSymbols();
     $this->suppressLoad = false;
     return $result;
   }
 
 
   /**
    * Select symbols matching the query and then instantiate them, returning
    * concrete objects. This is a convenience method which simplifies symbol
    * handling if you are only interested in building objects.
    *
    * If you want to do more than build objects, or want to build objects with
    * varying constructor arguments, use @{method:selectAndLoadSymbols} for
    * fine-grained control over results.
    *
    * This method implicitly restricts the query to match only concrete
    * classes.
    *
    * @param  list<wild>           List of constructor arguments.
    * @return map<string, object>  Map of class names to constructed objects.
    */
   public function loadObjects(array $argv = array()) {
     $symbols = $this
       ->setConcreteOnly(true)
       ->setType('class')
       ->selectAndLoadSymbols();
 
     $objects = array();
     foreach ($symbols as $symbol) {
       $objects[$symbol['name']] = newv($symbol['name'], $argv);
     }
 
     return $objects;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * @task internal
    */
   private function selectDescendantsOf(array $tree, $root) {
     $result = array();
 
     if (empty($tree[$root])) {
       // No known descendants.
       return array();
     }
 
     foreach ($tree[$root] as $child) {
       $result[$child] = true;
       if (!empty($tree[$child])) {
         $result += $this->selectDescendantsOf($tree, $child);
       }
     }
     return $result;
   }
 
 
   /**
    * @task internal
    */
   private function loadSymbol(array $symbol_spec) {
     // Check if we've already loaded the symbol; bail if we have.
     $name = $symbol_spec['name'];
     $is_function = ($symbol_spec['type'] == 'function');
 
     if ($is_function) {
       if (function_exists($name)) {
         return;
       }
     } else {
       if (class_exists($name, false) || interface_exists($name, false)) {
         return;
       }
     }
 
     $lib_name = $symbol_spec['library'];
     $where = $symbol_spec['where'];
     $bootloader = PhutilBootloader::getInstance();
 
     $bootloader->loadLibrarySource($lib_name, $where);
 
     // Check that we successfully loaded the symbol from wherever it was
     // supposed to be defined.
 
     $load_failed = null;
     if ($is_function) {
       if (!function_exists($name)) {
-        $load_failed = 'function';
+        $load_failed = pht('function');
       }
     } else {
       if (!class_exists($name, false) && !interface_exists($name, false)) {
-        $load_failed = 'class/interface';
+        $load_failed = pht('class or interface');
       }
     }
 
     if ($load_failed !== null) {
       $lib_path = phutil_get_library_root($lib_name);
       throw new PhutilMissingSymbolException(
         $name,
         $load_failed,
         pht(
-          'The symbol map for library "%s" (at "%s") claims this symbol '.
-          '(of type "%s") is defined in "%s", but loading that source file '.
-          'did not cause the symbol to become defined.',
+          "The symbol map for library '%s' (at '%s') claims this %s is ".
+          "defined in '%s', but loading that source file did not cause the ".
+          "%s to become defined.",
           $lib_name,
           $lib_path,
           $load_failed,
-          $where));
+          $where,
+          $load_failed));
     }
   }
 
 }
diff --git a/src/unit/engine/phutil/PhutilTestCase.php b/src/unit/engine/phutil/PhutilTestCase.php
index f16d9f2b..fddb0681 100644
--- a/src/unit/engine/phutil/PhutilTestCase.php
+++ b/src/unit/engine/phutil/PhutilTestCase.php
@@ -1,751 +1,785 @@
 <?php
 
 /**
  * Base test case for the very simple libphutil test framework.
  *
  * @task assert       Making Test Assertions
  * @task exceptions   Exception Handling
  * @task hook         Hooks for Setup and Teardown
  * @task internal     Internals
  */
 abstract class PhutilTestCase extends Phobject {
 
   private $assertions = 0;
   private $runningTest;
   private $testStartTime;
   private $results = array();
   private $enableCoverage;
   private $coverage = array();
   private $workingCopy;
   private $paths;
   private $renderer;
 
+  private static $executables = array();
 
 /* -(  Making Test Assertions  )--------------------------------------------- */
 
 
   /**
    * Assert that a value is `false`, strictly. The test fails if it is not.
    *
    * @param wild    The empirically derived value, generated by executing the
    *                test.
    * @param string  A human-readable description of what these values represent,
    *                and particularly of what a discrepancy means.
    *
    * @return void
    * @task assert
    */
   final protected function assertFalse($result, $message = null) {
     if ($result === false) {
       $this->assertions++;
       return;
     }
 
     $this->failAssertionWithExpectedValue('false', $result, $message);
   }
 
 
   /**
    * Assert that a value is `true`, strictly. The test fails if it is not.
    *
    * @param wild    The empirically derived value, generated by executing the
    *                test.
    * @param string  A human-readable description of what these values represent,
    *                and particularly of what a discrepancy means.
    *
    * @return void
    * @task assert
    */
   final protected function assertTrue($result, $message = null) {
     if ($result === true) {
       $this->assertions++;
       return;
     }
 
     $this->failAssertionWithExpectedValue('true', $result, $message);
   }
 
 
   /**
    * Assert that two values are equal, strictly. The test fails if they are not.
    *
    * NOTE: This method uses PHP's strict equality test operator (`===`) to
    * compare values. This means values and types must be equal, key order must
    * be identical in arrays, and objects must be referentially identical.
    *
    * @param wild    The theoretically expected value, generated by careful
    *                reasoning about the properties of the system.
    * @param wild    The empirically derived value, generated by executing the
    *                test.
    * @param string  A human-readable description of what these values represent,
    *                and particularly of what a discrepancy means.
    *
    * @return void
    * @task assert
    */
   final protected function assertEqual($expect, $result, $message = null) {
     if ($expect === $result) {
       $this->assertions++;
       return;
     }
 
     $expect = PhutilReadableSerializer::printableValue($expect);
     $result = PhutilReadableSerializer::printableValue($result);
     $caller = self::getCallerInfo();
     $file = $caller['file'];
     $line = $caller['line'];
 
     if ($message !== null) {
       $output = pht(
         'Assertion failed, expected values to be equal (at %s:%d): %s',
         $file,
         $line,
         $message);
     } else {
       $output = pht(
         'Assertion failed, expected values to be equal (at %s:%d).',
         $file,
         $line);
     }
 
     $output .= "\n";
 
     if (strpos($expect, "\n") === false && strpos($result, "\n") === false) {
       $output .= pht("Expected: %s\n  Actual: %s", $expect, $result);
     } else {
       $output .= pht(
         "Expected vs Actual Output Diff\n%s",
         ArcanistDiffUtils::renderDifferences(
           $expect,
           $result,
           $lines = 0xFFFF));
     }
 
     $this->failTest($output);
     throw new PhutilTestTerminatedException($output);
   }
 
 
   /**
    * Assert an unconditional failure. This is just a convenience method that
    * better indicates intent than using dummy values with assertEqual(). This
    * causes test failure.
    *
    * @param   string  Human-readable description of the reason for test failure.
    * @return  void
    * @task    assert
    */
   final protected function assertFailure($message) {
     $this->failTest($message);
     throw new PhutilTestTerminatedException($message);
   }
 
   /**
    * End this test by asserting that the test should be skipped for some
    * reason.
    *
    * @param   string  Reason for skipping this test.
    * @return  void
    * @task    assert
    */
   final protected function assertSkipped($message) {
     $this->skipTest($message);
     throw new PhutilTestSkippedException($message);
   }
 
 
 /* -(  Exception Handling  )------------------------------------------------- */
 
 
   /**
    * This simplest way to assert exceptions are thrown.
    *
    * @param exception   The expected exception.
    * @param callable    The thing which throws the exception.
    *
    * @return void
    * @task exceptions
    */
   final protected function assertException(
     $expected_exception_class,
     $callable) {
 
     $this->tryTestCases(
       array('assertException' => array()),
       array(false),
       $callable,
       $expected_exception_class);
   }
 
   /**
    * Straightforward method for writing unit tests which check if some block of
    * code throws an exception. For example, this allows you to test the
    * exception behavior of ##is_a_fruit()## on various inputs:
    *
    *    public function testFruit() {
    *      $this->tryTestCases(
    *        array(
    *          'apple is a fruit'    => new Apple(),
    *          'rock is not a fruit' => new Rock(),
    *        ),
    *        array(
    *          true,
    *          false,
    *        ),
    *        array($this, 'tryIsAFruit'),
    *        'NotAFruitException');
    *    }
    *
    *    protected function tryIsAFruit($input) {
    *      is_a_fruit($input);
    *    }
    *
    * @param map       Map of test case labels to test case inputs.
    * @param list      List of expected results, true to indicate that the case
    *                  is expected to succeed and false to indicate that the case
    *                  is expected to throw.
    * @param callable  Callback to invoke for each test case.
    * @param string    Optional exception class to catch, defaults to
    *                  'Exception'.
    * @return void
    * @task exceptions
    */
   final protected function tryTestCases(
     array $inputs,
     array $expect,
     $callable,
     $exception_class = 'Exception') {
 
     if (count($inputs) !== count($expect)) {
       $this->assertFailure(
         pht('Input and expectations must have the same number of values.'));
     }
 
     $labels = array_keys($inputs);
     $inputs = array_values($inputs);
     $expecting = array_values($expect);
     foreach ($inputs as $idx => $input) {
       $expect = $expecting[$idx];
       $label  = $labels[$idx];
 
       $caught = null;
       try {
         call_user_func($callable, $input);
       } catch (Exception $ex) {
         if ($ex instanceof PhutilTestTerminatedException) {
           throw $ex;
         }
         if (!($ex instanceof $exception_class)) {
           throw $ex;
         }
         $caught = $ex;
       }
 
       $actual = !($caught instanceof Exception);
 
       if ($expect === $actual) {
         if ($expect) {
           $message = pht("Test case '%s' did not throw, as expected.", $label);
         } else {
           $message = pht("Test case '%s' threw, as expected.", $label);
         }
       } else {
         if ($expect) {
           $message = pht(
             "Test case '%s' was expected to succeed, but it ".
             "raised an exception of class %s with message: %s",
             $label,
             get_class($ex),
             $ex->getMessage());
         } else {
           $message = pht(
             "Test case '%s' was expected to raise an ".
             "exception, but it did not throw anything.",
             $label);
         }
       }
 
       $this->assertEqual($expect, $actual, $message);
     }
   }
 
 
   /**
    * Convenience wrapper around @{method:tryTestCases} for cases where your
    * inputs are scalar. For example:
    *
    *    public function testFruit() {
    *      $this->tryTestCaseMap(
    *        array(
    *          'apple' => true,
    *          'rock'  => false,
    *        ),
    *        array($this, 'tryIsAFruit'),
    *        'NotAFruitException');
    *    }
    *
    *    protected function tryIsAFruit($input) {
    *      is_a_fruit($input);
    *    }
    *
    * For cases where your inputs are not scalar, use @{method:tryTestCases}.
    *
    * @param map       Map of scalar test inputs to expected success (true
    *                  expects success, false expects an exception).
    * @param callable  Callback to invoke for each test case.
    * @param string    Optional exception class to catch, defaults to
    *                  'Exception'.
    * @return void
    * @task exceptions
    */
   final protected function tryTestCaseMap(
     array $map,
     $callable,
     $exception_class = 'Exception') {
 
     return $this->tryTestCases(
       array_fuse(array_keys($map)),
       array_values($map),
       $callable,
       $exception_class);
   }
 
 
 /* -(  Hooks for Setup and Teardown  )--------------------------------------- */
 
 
   /**
    * This hook is invoked once, before any tests in this class are run. It
    * gives you an opportunity to perform setup steps for the entire class.
    *
    * @return void
    * @task hook
    */
   protected function willRunTests() {
     return;
   }
 
 
   /**
    * This hook is invoked once, after any tests in this class are run. It gives
    * you an opportunity to perform teardown steps for the entire class.
    *
    * @return void
    * @task hook
    */
   protected function didRunTests() {
     return;
   }
 
 
   /**
    * This hook is invoked once per test, before the test method is invoked.
    *
    * @param string Method name of the test which will be invoked.
    * @return void
    * @task hook
    */
   protected function willRunOneTest($test_method_name) {
     return;
   }
 
 
   /**
    * This hook is invoked once per test, after the test method is invoked.
    *
    * @param string Method name of the test which was invoked.
    * @return void
    * @task hook
    */
   protected function didRunOneTest($test_method_name) {
     return;
   }
 
 
   /**
    * This hook is invoked once, before any test cases execute. It gives you
    * an opportunity to perform setup steps for the entire suite of test cases.
    *
    * @param list<PhutilTestCase> List of test cases to be run.
    * @return void
    * @task hook
    */
   public function willRunTestCases(array $test_cases) {
     return;
   }
 
 
   /**
    * This hook is invoked once, after all test cases execute.
    *
    * @param list<PhutilTestCase> List of test cases that ran.
    * @return void
    * @task hook
    */
   public function didRunTestCases(array $test_cases) {
     return;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Construct a new test case. This method is ##final##, use willRunTests() to
    * provide test-wide setup logic.
    *
    * @task internal
    */
   final public function __construct() {}
 
 
   /**
    * Mark the currently-running test as a failure.
    *
    * @param string  Human-readable description of problems.
    * @return void
    *
    * @task internal
    */
   final private function failTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_FAIL, $reason);
   }
 
 
   /**
    * This was a triumph. I'm making a note here: HUGE SUCCESS.
    *
    * @param string  Human-readable overstatement of satisfaction.
    * @return void
    *
    * @task internal
    */
   final private function passTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_PASS, $reason);
   }
 
 
   /**
    * Mark the current running test as skipped.
    *
    * @param string  Description for why this test was skipped.
    * @return void
    * @task internal
    */
   final private function skipTest($reason) {
     $this->resultTest(ArcanistUnitTestResult::RESULT_SKIP, $reason);
   }
 
 
   final private function resultTest($test_result, $reason) {
     $coverage = $this->endCoverage();
 
     $result = new ArcanistUnitTestResult();
     $result->setCoverage($coverage);
     $result->setNamespace(get_class($this));
     $result->setName($this->runningTest);
     $result->setLink($this->getLink($this->runningTest));
     $result->setResult($test_result);
     $result->setDuration(microtime(true) - $this->testStartTime);
     $result->setUserData($reason);
     $this->results[] = $result;
 
     if ($this->renderer) {
       echo $this->renderer->renderUnitResult($result);
     }
   }
 
 
   /**
    * Execute the tests in this test case. You should not call this directly;
    * use @{class:PhutilUnitTestEngine} to orchestrate test execution.
    *
    * @return void
    * @task internal
    */
   final public function run() {
     $this->results = array();
 
     $reflection = new ReflectionClass($this);
     $methods = $reflection->getMethods();
 
     // Try to ensure that poorly-written tests which depend on execution order
     // (and are thus not properly isolated) will fail.
     shuffle($methods);
 
     $this->willRunTests();
     foreach ($methods as $method) {
       $name = $method->getName();
       if (preg_match('/^test/', $name)) {
         $this->runningTest = $name;
         $this->assertions = 0;
         $this->testStartTime = microtime(true);
 
         try {
           $this->willRunOneTest($name);
 
           $this->beginCoverage();
           $exceptions = array();
           try {
             call_user_func_array(
               array($this, $name),
               array());
             $this->passTest(
               pht(
                 '%s assertion(s) passed.',
                 new PhutilNumber($this->assertions)));
           } catch (Exception $ex) {
             $exceptions['Execution'] = $ex;
           }
 
           try {
             $this->didRunOneTest($name);
           } catch (Exception $ex) {
             $exceptions['Shutdown'] = $ex;
           }
 
           if ($exceptions) {
             if (count($exceptions) == 1) {
               throw head($exceptions);
             } else {
               throw new PhutilAggregateException(
                 pht('Multiple exceptions were raised during test execution.'),
                 $exceptions);
             }
           }
 
           if (!$this->assertions) {
             $this->failTest(
               pht(
                 'This test case made no assertions. Test cases must make at '.
                 'least one assertion.'));
           }
 
         } catch (PhutilTestTerminatedException $ex) {
           // Continue with the next test.
         } catch (PhutilTestSkippedException $ex) {
           // Continue with the next test.
         } catch (Exception $ex) {
           $ex_class = get_class($ex);
           $ex_message = $ex->getMessage();
           $ex_trace = $ex->getTraceAsString();
           $message = sprintf(
             "%s (%s): %s\n%s",
             pht('EXCEPTION'),
             $ex_class,
             $ex_message,
             $ex_trace);
           $this->failTest($message);
         }
       }
     }
     $this->didRunTests();
 
     return $this->results;
   }
 
   final public function setEnableCoverage($enable_coverage) {
     $this->enableCoverage = $enable_coverage;
     return $this;
   }
 
   /**
    * @phutil-external-symbol function xdebug_start_code_coverage
    */
   final private function beginCoverage() {
     if (!$this->enableCoverage) {
       return;
     }
 
     $this->assertCoverageAvailable();
     xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
   }
 
   /**
    * @phutil-external-symbol function xdebug_get_code_coverage
    * @phutil-external-symbol function xdebug_stop_code_coverage
    */
   final private function endCoverage() {
     if (!$this->enableCoverage) {
       return;
     }
 
     $result = xdebug_get_code_coverage();
     xdebug_stop_code_coverage($cleanup = false);
 
     $coverage = array();
 
     foreach ($result as $file => $report) {
       $project_root = $this->getProjectRoot();
 
       if (strncmp($file, $project_root, strlen($project_root))) {
         continue;
       }
 
       $max = max(array_keys($report));
       $str = '';
       for ($ii = 1; $ii <= $max; $ii++) {
         $c = null;
         if (isset($report[$ii])) {
           $c = $report[$ii];
         }
         if ($c === -1) {
           $str .= 'U'; // Un-covered.
         } else if ($c === -2) {
           // TODO: This indicates "unreachable", but it flags the closing braces
           // of functions which end in "return", which is super ridiculous. Just
           // ignore it for now.
           //
           // See http://bugs.xdebug.org/view.php?id=1041
           $str .= 'N'; // Not executable.
         } else if ($c === 1) {
           $str .= 'C'; // Covered.
         } else {
           $str .= 'N'; // Not executable.
         }
       }
       $coverage[substr($file, strlen($project_root) + 1)] = $str;
     }
 
     // Only keep coverage information for files modified by the change. In
     // the case of --everything, we won't have paths, so just return all the
     // coverage data.
     if ($this->paths) {
       $coverage = array_select_keys($coverage, $this->paths);
     }
 
     return $coverage;
   }
 
   final private function assertCoverageAvailable() {
     if (!function_exists('xdebug_start_code_coverage')) {
       throw new Exception(
         pht("You've enabled code coverage but XDebug is not installed."));
     }
   }
 
   final public function getWorkingCopy() {
     return $this->workingCopy;
   }
 
   final public function setWorkingCopy(
     ArcanistWorkingCopyIdentity $working_copy) {
 
     $this->workingCopy = $working_copy;
     return $this;
   }
 
   final public function getProjectRoot() {
     $working_copy = $this->getWorkingCopy();
 
     if (!$working_copy) {
       throw new PhutilInvalidStateException('setWorkingCopy');
     }
 
     return $working_copy->getProjectRoot();
   }
 
   final public function setPaths(array $paths) {
     $this->paths = $paths;
     return $this;
   }
 
   final protected function getLink($method) {
     $base_uri = $this
       ->getWorkingCopy()
       ->getProjectConfig('phabricator.uri');
 
     $uri = id(new PhutilURI($base_uri))
       ->setPath("/diffusion/symbol/{$method}/")
       ->setQueryParam('context', get_class($this))
       ->setQueryParam('jump', 'true')
       ->setQueryParam('lang', 'php');
 
     return (string)$uri;
   }
 
   final public function setRenderer(ArcanistUnitRenderer $renderer) {
     $this->renderer = $renderer;
     return $this;
   }
 
   /**
    * Returns info about the caller function.
    *
    * @return map
    */
   final private static function getCallerInfo() {
     $callee = array();
     $caller = array();
     $seen = false;
 
     foreach (array_slice(debug_backtrace(), 1) as $location) {
       $function = idx($location, 'function');
 
       if (!$seen && preg_match('/^assert[A-Z]/', $function)) {
         $seen = true;
         $caller = $location;
       } else if ($seen && !preg_match('/^assert[A-Z]/', $function)) {
         $callee = $location;
         break;
       }
     }
 
     return array(
       'file' => basename(idx($caller, 'file')),
       'line' => idx($caller, 'line'),
       'function' => idx($callee, 'function'),
       'class' => idx($callee, 'class'),
       'object' => idx($caller, 'object'),
       'type' => idx($callee, 'type'),
       'args' => idx($caller, 'args'),
     );
   }
 
 
   /**
    * Fail an assertion which checks that some result is equal to a specific
    * value, like 'true' or 'false'. This prints a readable error message and
    * fails the current test.
    *
    * This method throws and does not return.
    *
    * @param   string      Human readable description of the expected value.
    * @param   string      The actual value.
    * @param   string|null Optional assertion message.
    * @return  void
    * @task    internal
    */
   private function failAssertionWithExpectedValue(
     $expect_description,
     $actual_result,
     $message) {
 
     $caller = self::getCallerInfo();
     $file = $caller['file'];
     $line = $caller['line'];
 
     if ($message !== null) {
       $description = pht(
         "Assertion failed, expected '%s' (at %s:%d): %s",
         $expect_description,
         $file,
         $line,
         $message);
     } else {
       $description = pht(
         "Assertion failed, expected '%s' (at %s:%d).",
         $expect_description,
         $file,
         $line);
     }
 
     $actual_result = PhutilReadableSerializer::printableValue($actual_result);
     $header = pht('ACTUAL VALUE');
     $output = $description."\n\n".$header."\n".$actual_result;
 
     $this->failTest($output);
     throw new PhutilTestTerminatedException($output);
   }
 
+  final protected function assertExecutable($binary) {
+    if (!isset(self::$executables[$binary])) {
+      switch ($binary) {
+        case 'xhpast':
+          $ok = true;
+          if (!PhutilXHPASTBinary::isAvailable()) {
+            try {
+              PhutilXHPASTBinary::build();
+            } catch (Exception $ex) {
+              $ok = false;
+            }
+          }
+          break;
+        default:
+          $ok = Filesystem::binaryExists($binary);
+          break;
+      }
+
+      self::$executables[$binary] = $ok;
+    }
+
+    if (!self::$executables[$binary]) {
+      $this->assertSkipped(
+        pht('Required executable "%s" is not available.', $binary));
+    }
+  }
+
+  final protected function getSupportExecutable($executable) {
+    $root = dirname(phutil_get_library_root('arcanist'));
+    return $root.'/support/unit/'.$executable.'.php';
+  }
+
+
 }
diff --git a/src/utils/PhutilExecutionEnvironment.php b/src/utils/PhutilExecutionEnvironment.php
index 58281899..f9e2b1ba 100644
--- a/src/utils/PhutilExecutionEnvironment.php
+++ b/src/utils/PhutilExecutionEnvironment.php
@@ -1,16 +1,46 @@
 <?php
 
 /**
  * Get information about the current execution environment.
  */
 final class PhutilExecutionEnvironment extends Phobject {
 
   public static function getOSXVersion() {
     if (php_uname('s') != 'Darwin') {
       return null;
     }
 
     return php_uname('r');
   }
 
+  /**
+   * If the PHP configuration setting "variables_order" does not include "E",
+   * the `$_ENV` superglobal is not populated with the containing environment.
+   * For details, see T12071.
+   *
+   * This can be fixed by adding "E" to the configuration, but we can also
+   * repair it ourselves by re-executing a subprocess with the configuration
+   * option defined to include "E". This is clumsy, but saves users from
+   * needing to go find and edit their PHP files.
+   *
+   * @return void
+   */
+  public static function repairMissingVariablesOrder() {
+    $variables_order = ini_get('variables_order');
+    $variables_order = strtoupper($variables_order);
+
+    if (strpos($variables_order, 'E') !== false) {
+      // The "variables_order" option already has "E", so we don't need to
+      // repair $_ENV.
+      return;
+    }
+
+    list($env) = execx(
+      'php -d variables_order=E -r %s',
+      'echo json_encode($_ENV);');
+    $env = phutil_json_decode($env);
+
+    $_ENV = $_ENV + $env;
+  }
+
 }
diff --git a/src/utils/__tests__/PhutilUTF8TestCase.php b/src/utils/__tests__/PhutilUTF8TestCase.php
index 84c35cb3..7e85f89c 100644
--- a/src/utils/__tests__/PhutilUTF8TestCase.php
+++ b/src/utils/__tests__/PhutilUTF8TestCase.php
@@ -1,813 +1,827 @@
 <?php
 
 /**
  * Test cases for functions in utf8.php.
  */
 final class PhutilUTF8TestCase extends PhutilTestCase {
 
   public function testUTF8izeASCIIIgnored() {
     $input = "this\x01 is a \x7f test string";
     $this->assertEqual($input, phutil_utf8ize($input));
   }
 
   public function testUTF8izeUTF8Ignored() {
     $input = "\xc3\x9c \xc3\xbc \xe6\x9d\xb1!";
     $this->assertEqual($input, phutil_utf8ize($input));
   }
 
   public function testUTF8izeLongStringNosegfault() {
     // For some reason my laptop is segfaulting on long inputs inside
     // preg_match(). Forestall this craziness in the common case, at least.
     phutil_utf8ize(str_repeat('x', 1024 * 1024));
     $this->assertTrue(true);
   }
 
   public function testUTF8izeInvalidUTF8Fixed() {
     $input =
       "\xc3 this has \xe6\x9d some invalid utf8 \xe6";
     $expect =
       "\xEF\xBF\xBD this has \xEF\xBF\xBD\xEF\xBF\xBD some invalid utf8 ".
       "\xEF\xBF\xBD";
     $result = phutil_utf8ize($input);
     $this->assertEqual($expect, $result);
   }
 
   public function testUTF8izeOwlIsCuteAndFerocious() {
     // This was once a ferocious owl when we used to use "?" as the replacement
     // character instead of U+FFFD, but now he is sort of not as cute or
     // ferocious.
     $input = "M(o\xEE\xFF\xFFo)M";
     $expect = "M(o\xEF\xBF\xBD\xEF\xBF\xBD\xEF\xBF\xBDo)M";
     $result = phutil_utf8ize($input);
     $this->assertEqual($expect, $result);
   }
 
   public function testOverlongFormFiltering() {
     $bad = "\xEF\xBF\xBD";
 
     $map = array(
       'quack' => 'quack',
 
       // This is U+1000, a valid character.
       "\xE1\x80\x80" => "\xE1\x80\x80",
 
       // This is a 2-byte encoding of U+0000.
       "\xC0\x80" => "{$bad}{$bad}",
 
       // This is a 3-byte encoding of U+0020.
       "\xE0\x80\xA0" => "{$bad}{$bad}{$bad}",
 
       "A \xE0\x83\x83" => "A {$bad}{$bad}{$bad}",
     );
 
     foreach ($map as $input => $expect) {
+      if ($input !== $expect) {
+        $this->assertEqual(
+          false,
+          phutil_is_utf8_slowly($input),
+          pht('Slowly reject overlong form of: %s', $input));
+      }
+
       $actual = phutil_utf8ize($input);
       $this->assertEqual(
         $expect,
         $actual,
         pht('Overlong form canonicalization of: %s', $input));
     }
   }
 
   public function testSurrogateFiltering() {
     $bad = "\xEF\xBF\xBD";
 
     $map = array(
       "A \xED\xA9\x98" => "A {$bad}{$bad}{$bad}",
     );
 
     foreach ($map as $input => $expect) {
+      if ($input !== $expect) {
+        $this->assertEqual(
+          false,
+          phutil_is_utf8_slowly($input),
+          pht('Slowly reject surrogate: %s', $input));
+      }
+
       $actual = phutil_utf8ize($input);
       $this->assertEqual(
         $expect,
         $actual,
         pht('Surrogate filtering: %s', $input));
     }
   }
 
 
   public function testUTF8CodepointEncoding() {
     $map = array(
       0x20 => ' ',
       0x7E => '~',
       0xE9 => "\xC3\xA9",
       0x2603 => "\xE2\x98\x83",
       0x1F417 => "\xF0\x9F\x90\x97",
     );
 
     foreach ($map as $input => $expect) {
       $actual = phutil_utf8_encode_codepoint($input);
       $this->assertEqual(
         $expect,
         $actual,
         pht('UTF8 codepoint encoding of "%s".', $input));
     }
   }
 
   public function testUTF8len() {
     $strings = array(
       ''                => 0,
       'x'               => 1,
       "\xEF\xBF\xBD"    => 1,
       "x\xe6\x9d\xb1y"  => 3,
       'xyz'             => 3,
       'quack'           => 5,
     );
     foreach ($strings as $str => $expect) {
       $this->assertEqual($expect, phutil_utf8_strlen($str), 'Length of '.$str);
     }
   }
 
   public function testUTF8v() {
     $strings = array(
       ''                  => array(),
       'x'                 => array('x'),
       'quack'             => array('q', 'u', 'a', 'c', 'k'),
       "x\xe6\x9d\xb1y"    => array('x', "\xe6\x9d\xb1", 'y'),
 
       // This is a combining character.
       "x\xCD\xA0y"        => array('x', "\xCD\xA0", 'y'),
     );
     foreach ($strings as $str => $expect) {
       $this->assertEqual($expect, phutil_utf8v($str), 'Vector of '.$str);
     }
   }
 
   public function testUTF8vCodepoints() {
     $strings = array(
       ''                  => array(),
       'x'                 => array(0x78),
       'quack'             => array(0x71, 0x75, 0x61, 0x63, 0x6B),
       "x\xe6\x9d\xb1y"    => array(0x78, 0x6771, 0x79),
 
       "\xC2\xBB"          => array(0x00BB),
       "\xE2\x98\x83"      => array(0x2603),
       "\xEF\xBF\xBF"      => array(0xFFFF),
       "\xF0\x9F\x92\xA9"  => array(0x1F4A9),
 
       // This is a combining character.
       "x\xCD\xA0y"        => array(0x78, 0x0360, 0x79),
     );
     foreach ($strings as $str => $expect) {
       $this->assertEqual(
         $expect,
         phutil_utf8v_codepoints($str),
         pht('Codepoint Vector of %s', $str));
     }
   }
 
   public function testUTF8ConsoleStrlen() {
     $strings = array(
       ''              => 0,
       "\0"            => 0,
       'x'             => 1,
 
       // Double-width chinese character.
       "\xe6\x9d\xb1"  => 2,
 
       // Combining character.
       "x\xCD\xA0y"    => 2,
 
       // Combining plus double-width.
       "\xe6\x9d\xb1\xCD\xA0y"  => 3,
 
       // Colors and formatting.
       "\x1B[1mx\x1B[m" => 1,
       "\x1B[1m\x1B[31mx\x1B[m" => 1,
     );
     foreach ($strings as $str => $expect) {
       $this->assertEqual(
         $expect,
         phutil_utf8_console_strlen($str),
         pht('Console Length of %s', $str));
     }
   }
 
   public function testUTF8shorten() {
     $inputs = array(
       array('1erp derp derp', 9, '', '1erp derp'),
       array('2erp derp derp', 12, '...', '2erp derp...'),
       array('derpxderpxderp', 12, '...', 'derpxderp...'),
       array("derp\xE2\x99\x83derpderp", 12, '...', "derp\xE2\x99\x83derp..."),
       array('', 12, '...', ''),
       array('derp', 12, '...', 'derp'),
       array('11111', 5, '2222', '11111'),
       array('111111', 5, '2222', '12222'),
 
       array('D1rp. Derp derp.', 7, '...', 'D1rp.'),
 
       // "D2rp." is a better shortening of this, but it's dramatically more
       // complicated to implement with the newer byte/glyph/character
       // shortening code.
       array('D2rp. Derp derp.', 5, '...', 'D2...'),
       array('D3rp. Derp derp.', 4, '...', 'D...'),
       array('D4rp. Derp derp.', 14, '...', 'D4rp. Derp...'),
       array('D5rpderp, derp derp', 16, '...', 'D5rpderp...'),
       array('D6rpderp, derp derp', 17, '...', 'D6rpderp, derp...'),
 
       // Strings with combining characters.
       array("Gr\xCD\xA0mpyCatSmiles", 8, '...', "Gr\xCD\xA0mpy..."),
       array("X\xCD\xA0\xCD\xA0\xCD\xA0Y", 1, '', "X\xCD\xA0\xCD\xA0\xCD\xA0"),
 
       array(
         'Derp, supercalafragalisticexpialadoshus',
         30,
         '...',
         'Derp, supercalafragalistice...',
       ),
 
       // If a string has only word-break characters in it, we should just cut
       // it, not produce only the terminal.
       array('((((((((((', 8, '...', '(((((...'),
 
       // Terminal is longer than requested input.
       array('derp', 3, 'quack', 'quack'),
 
       array(
         'O123: com/oracle/java/path/to/application/source/ThingFactory.java',
         32,
         '...',
         'O123: com/oracle/java/path/to...',
       ),
     );
 
     foreach ($inputs as $input) {
       list($string, $length, $terminal, $expect) = $input;
       $result = id(new PhutilUTF8StringTruncator())
         ->setMaximumGlyphs($length)
         ->setTerminator($terminal)
         ->truncateString($string);
       $this->assertEqual($expect, $result, pht('Shortening of %s', $string));
     }
   }
 
   public function testUTF8StringTruncator() {
     $cases = array(
       array(
         "o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0",
         6,
         "o\xCD\xA0!",
         6,
         "o\xCD\xA0o\xCD\xA0!",
         6,
         "o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0o\xCD\xA0",
       ),
       array(
         "X\xCD\xA0\xCD\xA0\xCD\xA0Y",
         6,
         '!',
         6,
         "X\xCD\xA0\xCD\xA0\xCD\xA0Y",
         6,
         "X\xCD\xA0\xCD\xA0\xCD\xA0Y",
       ),
       array(
         "X\xCD\xA0\xCD\xA0\xCD\xA0YZ",
         6,
         '!',
         5,
         "X\xCD\xA0\xCD\xA0\xCD\xA0!",
         2,
         "X\xCD\xA0\xCD\xA0\xCD\xA0!",
       ),
       array(
         "\xE2\x98\x83\xE2\x98\x83\xE2\x98\x83\xE2\x98\x83",
         4,
         "\xE2\x98\x83!",
         3,
         "\xE2\x98\x83\xE2\x98\x83!",
         3,
         "\xE2\x98\x83\xE2\x98\x83!",
       ),
     );
 
     foreach ($cases as $case) {
       list($input, $b_len, $b_out, $p_len, $p_out, $g_len, $g_out) = $case;
 
       $result = id(new PhutilUTF8StringTruncator())
         ->setMaximumBytes($b_len)
         ->setTerminator('!')
         ->truncateString($input);
       $this->assertEqual($b_out, $result, pht('byte-short of %s', $input));
 
       $result = id(new PhutilUTF8StringTruncator())
         ->setMaximumCodepoints($p_len)
         ->setTerminator('!')
         ->truncateString($input);
       $this->assertEqual($p_out, $result, pht('codepoint-short of %s', $input));
 
       $result = id(new PhutilUTF8StringTruncator())
         ->setMaximumGlyphs($g_len)
         ->setTerminator('!')
         ->truncateString($input);
       $this->assertEqual($g_out, $result, pht('glyph-short of %s', $input));
     }
   }
 
   public function testUTF8LargeTruncation() {
     // This is testing that our performance is reasonable when truncating a
     // large input into a small output. Runtime should be on the order of the
     // output size, not the input size.
 
     $whale = "\xF0\x9F\x90\xB3";
     $input = str_repeat($whale, 1024 * 1024);
 
     $result = id(new PhutilUTF8StringTruncator())
       ->setMaximumBytes(16)
       ->setTerminator('!')
       ->truncateString($input);
 
     $this->assertEqual(
       str_repeat($whale, 3).'!',
       $result,
       pht('Large truncation.'));
   }
 
   public function testUTF8Wrap() {
     $inputs = array(
       array(
         'aaaaaaa',
         3,
         array(
           'aaa',
           'aaa',
           'a',
         ),
       ),
       array(
         'aa<b>aaaaa',
         3,
         array(
           'aa<b>a',
           'aaa',
           'a',
         ),
       ),
       array(
         'aa&amp;aaaa',
         3,
         array(
           'aa&amp;',
           'aaa',
           'a',
         ),
       ),
       array(
         "aa\xe6\x9d\xb1aaaa",
         3,
         array(
           "aa\xe6\x9d\xb1",
           'aaa',
           'a',
         ),
       ),
       array(
         '',
         80,
         array(
         ),
       ),
       array(
         'a',
         80,
         array(
           'a',
         ),
       ),
     );
 
     foreach ($inputs as $input) {
       list($string, $width, $expect) = $input;
       $this->assertEqual(
         $expect,
         phutil_utf8_hard_wrap_html($string, $width),
         pht("Wrapping of '%s'.", $string));
     }
   }
 
   public function testUTF8NonHTMLWrap() {
     $inputs = array(
       array(
         'aaaaaaa',
         3,
         array(
           'aaa',
           'aaa',
           'a',
         ),
       ),
       array(
         'abracadabra!',
         4,
         array(
           'abra',
           'cada',
           'bra!',
         ),
       ),
       array(
         '',
         10,
         array(
         ),
       ),
       array(
         'a',
         20,
         array(
           'a',
         ),
       ),
       array(
         "aa\xe6\x9d\xb1aaaa",
         3,
         array(
           "aa\xe6\x9d\xb1",
           'aaa',
           'a',
         ),
       ),
       array(
         "mmm\nmmm\nmmmm",
         3,
         array(
           'mmm',
           'mmm',
           'mmm',
           'm',
         ),
       ),
     );
 
     foreach ($inputs as $input) {
       list($string, $width, $expect) = $input;
       $this->assertEqual(
         $expect,
         phutil_utf8_hard_wrap($string, $width),
         pht("Wrapping of '%s'", $string));
     }
   }
 
   public function testUTF8ConvertParams() {
     $caught = null;
     try {
       phutil_utf8_convert('', 'utf8', '');
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue((bool)$caught, pht('Requires source encoding.'));
 
     $caught = null;
     try {
       phutil_utf8_convert('', '', 'utf8');
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue((bool)$caught, pht('Requires target encoding.'));
   }
 
 
   public function testUTF8Convert() {
     if (!function_exists('mb_convert_encoding')) {
       $this->assertSkipped(pht('Requires %s extension.', 'mbstring'));
     }
 
     // "[ae]gis se[n]or [(c)] 1970 [+/-] 1 [degree]"
     $input = "\xE6gis SE\xD1OR \xA9 1970 \xB11\xB0";
     $expect = "\xC3\xA6gis SE\xC3\x91OR \xC2\xA9 1970 \xC2\xB11\xC2\xB0";
     $output = phutil_utf8_convert($input, 'UTF-8', 'ISO-8859-1');
 
     $this->assertEqual($expect, $output, pht('Conversion from ISO-8859-1.'));
 
     $caught = null;
     try {
       phutil_utf8_convert('xyz', 'moon language', 'UTF-8');
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue((bool)$caught, pht('Conversion with bogus encoding.'));
   }
 
 
   public function testUTF8ucwords() {
     $tests = array(
       '' => '',
       'x' => 'X',
       'X' => 'X',
       'five short graybles' => 'Five Short Graybles',
       'xXxSNiPeRKiLLeRxXx' => 'XXxSNiPeRKiLLeRxXx',
     );
 
     foreach ($tests as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_utf8_ucwords($input),
         'phutil_utf8_ucwords("'.$input.'")');
     }
   }
 
   public function testUTF8strtolower() {
     $tests = array(
       '' => '',
       'a' => 'a',
       'A' => 'a',
       '!' => '!',
       'OMG!~ LOLolol ROFLwaffle11~' => 'omg!~ lololol roflwaffle11~',
       "\xE2\x98\x83" => "\xE2\x98\x83",
     );
 
     foreach ($tests as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_utf8_strtolower($input),
         'phutil_utf8_strtolower("'.$input.'")');
     }
   }
 
   public function testUTF8strtoupper() {
     $tests = array(
       '' => '',
       'a' => 'A',
       'A' => 'A',
       '!' => '!',
       'Cats have 9 lives.' => 'CATS HAVE 9 LIVES.',
       "\xE2\x98\x83" => "\xE2\x98\x83",
     );
 
     foreach ($tests as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_utf8_strtoupper($input),
         'phutil_utf8_strtoupper("'.$input.'")');
     }
   }
 
   public function testUTF8IsCombiningCharacter() {
     $character = "\xCD\xA0";
     $this->assertEqual(
       true,
       phutil_utf8_is_combining_character($character));
 
     $character = 'a';
     $this->assertEqual(
       false,
       phutil_utf8_is_combining_character($character));
   }
 
   public function testUTF8vCombined() {
     // Empty string.
     $string = '';
     $this->assertEqual(array(), phutil_utf8v_combined($string));
 
     // Single character.
     $string = 'x';
     $this->assertEqual(array('x'), phutil_utf8v_combined($string));
 
     // No combining characters.
     $string = 'cat';
     $this->assertEqual(array('c', 'a', 't'), phutil_utf8v_combined($string));
 
     // String with a combining character in the middle.
     $string = "ca\xCD\xA0t";
     $this->assertEqual(
       array('c', "a\xCD\xA0", 't'),
       phutil_utf8v_combined($string));
 
     // String starting with a combined character.
     $string = "c\xCD\xA0at";
     $this->assertEqual(
       array("c\xCD\xA0", 'a', 't'),
       phutil_utf8v_combined($string));
 
     // String with trailing combining character.
     $string = "cat\xCD\xA0";
     $this->assertEqual(
       array('c', 'a', "t\xCD\xA0"),
       phutil_utf8v_combined($string));
 
     // String with muliple combined characters.
     $string = "c\xCD\xA0a\xCD\xA0t\xCD\xA0";
     $this->assertEqual(
       array("c\xCD\xA0", "a\xCD\xA0", "t\xCD\xA0"),
       phutil_utf8v_combined($string));
 
     // String with multiple combining characters.
     $string = "ca\xCD\xA0\xCD\xA0t";
     $this->assertEqual(
       array('c', "a\xCD\xA0\xCD\xA0", 't'),
       phutil_utf8v_combined($string));
 
     // String beginning with a combining character.
     $string = "\xCD\xA0\xCD\xA0c";
     $this->assertEqual(
       array(" \xCD\xA0\xCD\xA0", 'c'),
       phutil_utf8v_combined($string));
   }
 
   public function testUTF8BMPSegfaults() {
     // This test case fails by segfaulting, or passes by not segfaulting. See
     // the function implementation for details.
     $input = str_repeat("\xEF\xBF\xBF", 1024 * 32);
     phutil_is_utf8_with_only_bmp_characters($input);
 
     $this->assertTrue(true);
   }
 
   public function testCJK() {
     $map = array(
       '' => false,
       'a' => false,
       '.' => false,
       "\xE2\x98\x83" => false,
       "\xE5\xA0\xB1" => true,
     );
 
     foreach ($map as $input => $expect) {
       $actual = phutil_utf8_is_cjk($input);
 
       $this->assertEqual($expect, $actual, pht('CJK: "%s"', $input));
     }
   }
 
   public function testUTF8BMP() {
     $tests = array(
       ''  => array(
         true,
         true,
         pht('empty string'),
       ),
       'a' => array(
         true,
         true,
         'a',
       ),
       "a\xCD\xA0\xCD\xA0" => array(
         true,
         true,
         pht('%s with combining', 'a'),
       ),
       "\xE2\x98\x83" => array(
         true,
         true,
         pht('snowman'),
       ),
 
       // This is the last character in BMP, U+FFFF.
       "\xEF\xBF\xBF" => array(
         true,
         true,
         'U+FFFF',
       ),
 
       // This isn't valid.
       "\xEF\xBF\xC0" => array(
         false,
         false,
         pht('Invalid, byte range.'),
       ),
 
       // This is an invalid nonminimal representation.
       "\xF0\x81\x80\x80" => array(
         false,
         false,
         pht('Nonminimal 4-byte character.'),
       ),
 
       // This is the first character above BMP, U+10000.
       "\xF0\x90\x80\x80" => array(
         true,
         false,
         'U+10000',
       ),
       "\xF0\x9D\x84\x9E" => array(
         true,
         false,
         'gclef',
       ),
 
       "musical \xF0\x9D\x84\x9E g-clef" => array(
         true,
         false,
         pht('gclef text'),
       ),
       "\xF0\x9D\x84" => array(
         false,
         false,
         pht('Invalid, truncated.'),
       ),
 
       "\xE0\x80\x80" => array(
         false,
         false,
         pht('Nonminimal 3-byte character.'),
       ),
 
       // Partial BMP characters.
       "\xCD" => array(
         false,
         false,
         pht('Partial 2-byte character.'),
       ),
       "\xE0\xA0" => array(
         false,
         false,
         pht('Partial BMP 0xE0 character.'),
       ),
       "\xE2\x98" => array(
         false,
         false,
         pht('Partial BMP cahracter.'),
       ),
     );
 
     foreach ($tests as $input => $test) {
       list($expect_utf8, $expect_bmp, $test_name) = $test;
 
       // Depending on what's installed on the system, this may use an
       // extension.
       $this->assertEqual(
         $expect_utf8,
         phutil_is_utf8($input),
         pht('is_utf(%s)', $test_name));
 
       // Also test this against the pure PHP implementation, explicitly.
       $this->assertEqual(
         $expect_utf8,
         phutil_is_utf8_slowly($input),
         pht('is_utf_slowly(%s)', $test_name));
 
       $this->assertEqual(
         $expect_bmp,
         phutil_is_utf8_with_only_bmp_characters($input),
         pht('is_utf_bmp(%s)', $test_name));
     }
   }
 
   public function testSystemLocaleManagement() {
     $original_locale = phutil_get_system_locale();
     $this->assertTrue(
       (strlen($original_locale) > 0),
       pht('System has some identifiable locale.'));
 
     $this->assertFalse(
       phutil_is_system_locale_available('duck.quack'),
       pht('Imaginary locale should be unavailable.'));
 
     $this->assertEqual(
       $original_locale,
       phutil_get_system_locale(),
       pht('Testing locale availability should not change the locale.'));
 
     $this->assertTrue(
       phutil_is_system_locale_available($original_locale),
       pht('The current locale should be available.'));
 
     $caught = null;
     try {
       phutil_set_system_locale('duck.quack');
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue(
       ($caught instanceof Exception),
       pht('Setting an imaginary locale should raise an exception.'));
 
     // We need two locales for the next part because one of them might be the
     // current locale, and we want to make sure we can actually change the
     // locale value.
 
     // If the current locale was "zz_ZZ", and then we do this:
     //
     //   set_locale("zz_ZZ");
     //   assert("zz_ZZ" == get_locale());
     //
     // ...the test could pass even if "set_locale(...)" does nothing.
 
     $has_us = phutil_is_system_locale_available('en_US.UTF-8');
     $has_gb = phutil_is_system_locale_available('en_GB.UTF-8');
     if (!$has_us || !$has_gb) {
       $this->assertSkipped(
         pht(
           'System does not have en_US + en_GB to do locale adjustment '.
           'tests.'));
     }
 
     phutil_set_system_locale('en_US.UTF-8');
     $this->assertEqual(
       'en_US.UTF-8',
       phutil_get_system_locale(),
       pht('Set locale to en_US.'));
 
     phutil_set_system_locale('en_GB.UTF-8');
     $this->assertEqual(
       'en_GB.UTF-8',
       phutil_get_system_locale(),
       pht('Set locale to en_GB.'));
 
     // Put things back the way they were.
     phutil_set_system_locale($original_locale);
   }
 
 }
diff --git a/src/utils/__tests__/PhutilUtilsTestCase.php b/src/utils/__tests__/PhutilUtilsTestCase.php
index 530babcb..e1bade52 100644
--- a/src/utils/__tests__/PhutilUtilsTestCase.php
+++ b/src/utils/__tests__/PhutilUtilsTestCase.php
@@ -1,969 +1,969 @@
 <?php
 
 /**
  * Test cases for functions in utils.php.
  */
 final class PhutilUtilsTestCase extends PhutilTestCase {
 
   public function testMFilterNullMethodThrowException() {
     $caught = null;
     try {
       mfilter(array(), null);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
   }
 
 
   public function testMFilterWithEmptyValueFiltered() {
     $a = new MFilterTestHelper('o', 'p', 'q');
     $b = new MFilterTestHelper('o', '', 'q');
     $c = new MFilterTestHelper('o', 'p', 'q');
 
     $list = array(
       'a' => $a,
       'b' => $b,
       'c' => $c,
     );
 
     $actual = mfilter($list, 'getI');
     $expected = array(
      'a' => $a,
      'c' => $c,
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testMFilterWithEmptyValueNegateFiltered() {
     $a = new MFilterTestHelper('o', 'p', 'q');
     $b = new MFilterTestHelper('o', '', 'q');
     $c = new MFilterTestHelper('o', 'p', 'q');
 
     $list = array(
       'a' => $a,
       'b' => $b,
       'c' => $c,
     );
 
     $actual = mfilter($list, 'getI', true);
     $expected = array(
       'b' => $b,
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testIFilterInvalidIndexThrowException() {
     $caught = null;
     try {
       ifilter(array(), null);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
   }
 
   public function testIFilterWithEmptyValueFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
       'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
       'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
       'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
     );
 
     $actual = ifilter($list, 'i');
     $expected = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testIFilterIndexNotExistsAllFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
     );
 
      $actual = ifilter($list, 'NoneExisting');
      $expected = array();
 
      $this->assertEqual($expected, $actual);
   }
 
 
   public function testIFilterWithEmptyValueNegateFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
       'c' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
       'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
       'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
     );
 
     $actual = ifilter($list, 'i', true);
     $expected = array(
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
       'd' => array('h' => 'o', 'i' => 0, 'j' => 'q'),
       'e' => array('h' => 'o', 'i' => null, 'j' => 'q'),
       'f' => array('h' => 'o', 'i' => false, 'j' => 'q'),
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testIFilterIndexNotExistsNotFiltered() {
     $list = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
     );
 
     $actual = ifilter($list, 'NoneExisting', true);
     $expected = array(
       'a' => array('h' => 'o', 'i' => 'p', 'j' => 'q'),
       'b' => array('h' => 'o', 'i' => '', 'j' => 'q'),
     );
 
     $this->assertEqual($expected, $actual);
   }
 
   public function testmergevMergingBasicallyWorksCorrectly() {
     $this->assertEqual(
       array(),
       array_mergev(
         array(
           // <empty>
         )));
 
     $this->assertEqual(
       array(),
       array_mergev(
         array(
           array(),
           array(),
           array(),
         )));
 
     $this->assertEqual(
       array(1, 2, 3, 4, 5),
       array_mergev(
         array(
           array(1, 2),
           array(3),
           array(),
           array(4, 5),
         )));
 
     $not_valid = array(
       'scalar' => array(1),
       'array plus scalar' => array(array(), 1),
       'null' => array(null),
     );
 
     foreach ($not_valid as $key => $invalid_input) {
       $caught = null;
       try {
         array_mergev($invalid_input);
       } catch (InvalidArgumentException $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue(
         ($caught instanceof InvalidArgumentException),
         pht('%s invalid on %s', 'array_mergev()', $key));
     }
   }
 
   public function testNonempty() {
     $this->assertEqual(
       'zebra',
       nonempty(false, null, 0, '', array(), 'zebra'));
 
     $this->assertEqual(
       null,
       nonempty());
 
     $this->assertEqual(
       false,
       nonempty(null, false));
 
     $this->assertEqual(
       null,
       nonempty(false, null));
   }
 
   protected function tryAssertInstancesOfArray($input) {
     assert_instances_of($input, 'array');
   }
 
   protected function tryAssertInstancesOfStdClass($input) {
     assert_instances_of($input, 'stdClass');
   }
 
   public function testAssertInstancesOf() {
     $object = new stdClass();
     $inputs = array(
       'empty' => array(),
       'stdClass' => array($object, $object),
       __CLASS__ => array($object, $this),
       'array' => array(array(), array()),
       'integer' => array($object, 1),
     );
 
     $this->tryTestCases(
       $inputs,
       array(true, true, false, false, false),
       array($this, 'tryAssertInstancesOfStdClass'),
       'InvalidArgumentException');
 
     $this->tryTestCases(
       $inputs,
       array(true, false, false, true, false),
       array($this, 'tryAssertInstancesOfArray'),
       'InvalidArgumentException');
   }
 
   public function testAssertSameKeys() {
     $cases = array(
       array(true, array(), array()),
       array(true, array(0), array(1)),
 
       array(false, array(0), array()),
       array(false, array(), array(0)),
 
       array(false, array('a' => 1), array('b' => 1)),
 
       // Make sure "null" values survive "isset()" tests.
       array(true, array('a' => 1), array('a' => null)),
 
       // Key order should not matter.
       array(true, array('a' => 1, 'b' => 1), array('b' => 1, 'a' => 1)),
     );
 
     foreach ($cases as $case) {
       list($same_keys, $expect, $input) = $case;
 
       $caught = null;
       try {
         assert_same_keys($expect, $input);
       } catch (InvalidArgumentException $ex) {
         $caught = $ex;
       }
 
       $this->assertEqual($same_keys, ($caught === null));
     }
   }
 
   public function testAssertStringLike() {
     $this->assertEqual(
       null,
       assert_stringlike(null));
 
     $this->assertEqual(
       null,
       assert_stringlike(''));
 
     $this->assertEqual(
       null,
       assert_stringlike('Hello World'));
 
     $this->assertEqual(
       null,
       assert_stringlike(1));
 
     $this->assertEqual(
       null,
       assert_stringlike(9.9999));
 
     $this->assertEqual(
       null,
       assert_stringlike(true));
 
     $obj = new Exception('.');
     $this->assertEqual(
       null,
       assert_stringlike($obj));
 
     $obj = (object)array();
 
     try {
       assert_stringlike($obj);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
 
     $array = array(
       'foo' => 'bar',
       'bar' => 'foo',
     );
 
     try {
       assert_stringlike($array);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
 
     $tmp = new TempFile();
     $resource = fopen($tmp, 'r');
 
     try {
       assert_stringlike($resource);
     } catch (InvalidArgumentException $ex) {
       $caught = $ex;
     }
 
     fclose($resource);
 
     $this->assertTrue($caught instanceof InvalidArgumentException);
   }
 
   public function testCoalesce() {
     $this->assertEqual(
       'zebra',
       coalesce(null, 'zebra'));
 
     $this->assertEqual(
       null,
       coalesce());
 
     $this->assertEqual(
       false,
       coalesce(false, null));
 
     $this->assertEqual(
       false,
       coalesce(null, false));
   }
 
   public function testHeadLast() {
     $this->assertEqual(
       'a',
       head(explode('.', 'a.b')));
     $this->assertEqual(
       'b',
       last(explode('.', 'a.b')));
   }
 
   public function testHeadKeyLastKey() {
     $this->assertEqual(
       'a',
       head_key(array('a' => 0, 'b' => 1)));
     $this->assertEqual(
       'b',
       last_key(array('a' => 0, 'b' => 1)));
     $this->assertEqual(null, head_key(array()));
     $this->assertEqual(null, last_key(array()));
   }
 
   public function testID() {
     $this->assertEqual(true, id(true));
     $this->assertEqual(false, id(false));
   }
 
   public function testIdx() {
     $array = array(
       'present' => true,
       'null' => null,
     );
     $this->assertEqual(true, idx($array, 'present'));
     $this->assertEqual(true, idx($array, 'present', false));
     $this->assertEqual(null, idx($array, 'null'));
     $this->assertEqual(null, idx($array, 'null', false));
     $this->assertEqual(null, idx($array, 'missing'));
     $this->assertEqual(false, idx($array, 'missing', false));
   }
 
   public function testSplitLines() {
     $retain_cases = array(
       '' => array(''),
       'x' => array('x'),
       "x\n" => array("x\n"),
       "\n" => array("\n"),
       "\n\n\n" => array("\n", "\n", "\n"),
       "\r\n" => array("\r\n"),
       "x\r\ny\n" => array("x\r\n", "y\n"),
       "x\ry\nz\r\n" => array("x\ry\n", "z\r\n"),
       "x\ry\nz\r\n\n" => array("x\ry\n", "z\r\n", "\n"),
     );
 
     foreach ($retain_cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_split_lines($input, $retain_endings = true),
         pht('(Retained) %s', addcslashes($input, "\r\n\\")));
     }
 
     $discard_cases = array(
       '' => array(''),
       'x' => array('x'),
       "x\n" => array('x'),
       "\n" => array(''),
       "\n\n\n" => array('', '', ''),
       "\r\n" => array(''),
       "x\r\ny\n" => array('x', 'y'),
       "x\ry\nz\r\n" => array("x\ry", 'z'),
       "x\ry\nz\r\n\n" => array("x\ry", 'z', ''),
     );
 
     foreach ($discard_cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_split_lines($input, $retain_endings = false),
         pht('(Discarded) %s', addcslashes($input, "\r\n\\")));
     }
   }
 
   public function testArrayFuse() {
     $this->assertEqual(array(), array_fuse(array()));
     $this->assertEqual(array('x' => 'x'), array_fuse(array('x')));
   }
 
   public function testArrayInterleave() {
     $this->assertEqual(array(), array_interleave('x', array()));
     $this->assertEqual(array('y'), array_interleave('x', array('y')));
 
     $this->assertEqual(
       array('y', 'x', 'z'),
       array_interleave('x', array('y', 'z')));
 
     $this->assertEqual(
       array('y', 'x', 'z'),
       array_interleave(
         'x',
         array(
           'kangaroo' => 'y',
           'marmoset' => 'z',
         )));
 
     $obj1 = (object)array();
     $obj2 = (object)array();
 
     $this->assertEqual(
       array($obj1, $obj2, $obj1, $obj2, $obj1),
       array_interleave(
         $obj2,
         array(
           $obj1,
           $obj1,
           $obj1,
         )));
 
     $implode_tests = array(
       '' => array(1, 2, 3),
       'x' => array(1, 2, 3),
       'y' => array(),
       'z' => array(1),
     );
 
     foreach ($implode_tests as $x => $y) {
       $this->assertEqual(
         implode('', array_interleave($x, $y)),
         implode($x, $y));
     }
   }
 
   public function testLoggableString() {
     $this->assertEqual(
       '',
       phutil_loggable_string(''));
 
     $this->assertEqual(
       "a\\nb",
       phutil_loggable_string("a\nb"));
 
     $this->assertEqual(
       "a\\x01b",
       phutil_loggable_string("a\x01b"));
 
     $this->assertEqual(
       "a\\x1Fb",
       phutil_loggable_string("a\x1Fb"));
   }
 
   public function testPhutilUnits() {
     $cases = array(
       '0 seconds in seconds' => 0,
       '1 second in seconds' => 1,
       '2 seconds in seconds' => 2,
       '100 seconds in seconds' => 100,
       '2 minutes in seconds' => 120,
       '1 hour in seconds' => 3600,
       '1 day in seconds' => 86400,
       '3 days in seconds' => 259200,
       '128 bits in bytes' => 16,
       '1 byte in bytes' => 1,
       '8 bits in bytes' => 1,
       '1 minute in milliseconds' => 60000,
       '2 minutes in microseconds' => 120000000,
     );
 
     foreach ($cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_units($input),
         'phutil_units("'.$input.'")');
     }
 
     $bad_cases = array(
       'quack',
       '3 years in seconds',
       '1 day in days',
       '-1 minutes in seconds',
       '1.5 minutes in seconds',
       '7 bits in bytes',
       '2 hours in bytes',
       '1 dram in bytes',
       '24 bits in seconds',
     );
 
     foreach ($bad_cases as $input) {
       $caught = null;
       try {
         phutil_units($input);
       } catch (InvalidArgumentException $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue(
         ($caught instanceof InvalidArgumentException),
         'phutil_units("'.$input.'")');
     }
   }
 
   public function testPhutilJSONDecode() {
     $valid_cases = array(
       '{}' => array(),
       '[]' => array(),
       '[1, 2]' => array(1, 2),
       '{"a":"b"}' => array('a' => 'b'),
     );
 
     foreach ($valid_cases as $input => $expect) {
       $result = phutil_json_decode($input);
       $this->assertEqual($expect, $result, 'phutil_json_decode('.$input.')');
     }
 
     $invalid_cases = array(
       '',
       '"a"',
       '{,}',
       'null',
       '"null"',
     );
 
     foreach ($invalid_cases as $input) {
       $caught = null;
       try {
         phutil_json_decode($input);
       } catch (Exception $ex) {
         $caught = $ex;
       }
+
       $this->assertTrue($caught instanceof PhutilJSONParserException);
     }
   }
 
   public function testPhutilINIDecode() {
     // Skip the test if we are using an older version of PHP that doesn't
     // have the `parse_ini_string` function.
     try {
       phutil_ini_decode('');
     } catch (PhutilMethodNotImplementedException $ex) {
       $this->assertSkipped($ex->getMessage());
     }
 
     $valid_cases = array(
       '' => array(),
       'foo=' => array('foo' => ''),
       'foo=bar' => array('foo' => 'bar'),
       'foo = bar' => array('foo' => 'bar'),
       "foo = bar\n" => array('foo' => 'bar'),
       "foo\nbar = baz" => array('bar' => 'baz'),
 
       "[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
       "[foo]\n[bar]\nbaz = foo" => array(
         'foo' => array(),
         'bar' => array('baz' => 'foo'),
       ),
       "[foo]\nbar = baz\n\n[bar]\nbaz = foo" => array(
         'foo' => array('bar' => 'baz'),
         'bar' => array('baz' => 'foo'),
       ),
 
       "; Comment\n[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
       "# Comment\n[foo]\nbar = baz" => array('foo' => array('bar' => 'baz')),
 
       "foo = true\n[bar]\nbaz = false"
         => array('foo' => true, 'bar' => array('baz' => false)),
       "foo = 1\nbar = 1.234" => array('foo' => 1, 'bar' => 1.234),
       'x = {"foo": "bar"}' => array('x' => '{"foo": "bar"}'),
     );
 
     foreach ($valid_cases as $input => $expect) {
       $result = phutil_ini_decode($input);
       $this->assertEqual($expect, $result, 'phutil_ini_decode('.$input.')');
     }
 
     $invalid_cases = array(
       '[' => new PhutilINIParserException(),
     );
 
     foreach ($invalid_cases as $input => $expect) {
       $caught = null;
       try {
         phutil_ini_decode($input);
       } catch (Exception $ex) {
         $caught = $ex;
       }
       $this->assertTrue($caught instanceof $expect);
     }
   }
 
   public function testCensorCredentials() {
     $cases = array(
       '' => '',
       'abc' => 'abc',
 
       // NOTE: We're liberal about censoring here, since we can't tell
       // if this is a truncated password at the end of an input string
       // or a domain name. The version with a "/" isn't censored.
       'http://example.com' => 'http://********',
       'http://example.com/' => 'http://example.com/',
 
       'http://username@example.com' => 'http://********@example.com',
       'http://user:pass@example.com' => 'http://********@example.com',
 
       // We censor these because they might be truncated credentials at the end
       // of the string.
       'http://user' => 'http://********',
       "http://user\n" => "http://********\n",
 
       'svn+ssh://user:pass@example.com' => 'svn+ssh://********@example.com',
     );
 
     foreach ($cases as $input => $expect) {
       $this->assertEqual(
         $expect,
         phutil_censor_credentials($input),
         pht('Credential censoring for: %s', $input));
     }
   }
 
   public function testVarExport() {
     // Constants
     $this->assertEqual('null', phutil_var_export(null));
     $this->assertEqual('true', phutil_var_export(true));
     $this->assertEqual('false', phutil_var_export(false));
     $this->assertEqual("'quack'", phutil_var_export('quack'));
     $this->assertEqual('1234567', phutil_var_export(1234567));
 
     // Arrays
     $this->assertEqual(
       'array()',
       phutil_var_export(array()));
     $this->assertEqual(
       implode("\n", array(
         'array(',
         '  1,',
         '  2,',
         '  3,',
         ')',
       )),
       phutil_var_export(array(1, 2, 3)));
     $this->assertEqual(
       implode("\n", array(
         'array(',
         "  'foo' => 'bar',",
         "  'bar' => 'baz',",
         ')',
       )),
       phutil_var_export(array('foo' => 'bar', 'bar' => 'baz')));
     $this->assertEqual(
       implode("\n", array(
         'array(',
         "  'foo' => array(",
         "    'bar' => array(",
         "      'baz' => array(),",
         '    ),',
         '  ),',
         ')',
       )),
       phutil_var_export(
         array('foo' => array('bar' => array('baz' => array())))));
 
     // NOTE: Object behavior differs across PHP versions. Older versions of
     // PHP export objects as "stdClass::__set_state(array())". Newer versions
     // of PHP (7.3+) export objects as "(object) array()".
   }
 
   public function testFnmatch() {
     $cases = array(
       '' => array(
         array(''),
         array('.', '/'),
       ),
       '*' => array(
         array('file'),
         array('dir/', '/dir'),
       ),
       '**' => array(
         array('file', 'dir/', '/dir', 'dir/subdir/file'),
         array(),
       ),
       '**/file' => array(
         array('file', 'dir/file', 'dir/subdir/file', 'dir/subdir/subdir/file'),
         array('file/', 'file/dir'),
       ),
       'file.*' => array(
         array('file.php', 'file.a', 'file.'),
         array('files.php', 'file.php/blah'),
       ),
       'fo?' => array(
         array('foo', 'fot'),
         array('fooo', 'ffoo', 'fo/', 'foo/'),
       ),
       'fo{o,t}' => array(
         array('foo', 'fot'),
         array('fob', 'fo/', 'foo/'),
       ),
       'fo{o,\\,}' => array(
         array('foo', 'fo,'),
         array('foo/', 'fo,/'),
       ),
       'fo{o,\\\\}' => array(
         array('foo', 'fo\\'),
         array('foo/', 'fo\\/'),
       ),
       '/foo' => array(
         array('/foo'),
         array('foo', '/foo/'),
       ),
 
       // Tests for various `fnmatch` flags.
       '*.txt' => array(
         array(
           'file.txt',
 
           // FNM_PERIOD
           '.secret-file.txt',
         ),
         array(
           // FNM_PATHNAME
           'dir/file.txt',
 
           // FNM_CASEFOLD
           'file.TXT',
         ),
         '\\*.txt' => array(
           array(
             // FNM_NOESCAPE
             '*.txt',
           ),
           array(
             'file.txt',
           ),
         ),
       ),
     );
 
     $invalid = array(
       '{',
       'asdf\\',
     );
 
     foreach ($cases as $input => $expect) {
       list($matches, $no_matches) = $expect;
 
       foreach ($matches as $match) {
         $this->assertTrue(
           phutil_fnmatch($input, $match),
           pht('Expecting "%s" to match "%s".', $input, $match));
       }
 
       foreach ($no_matches as $no_match) {
         $this->assertFalse(
           phutil_fnmatch($input, $no_match),
           pht('Expecting "%s" not to match "%s".', $input, $no_match));
       }
     }
 
     foreach ($invalid as $input) {
       $caught = null;
       try {
         phutil_fnmatch($input, '');
       } catch (Exception $ex) {
         $caught = $ex;
       }
 
       $this->assertTrue($caught instanceof InvalidArgumentException);
     }
   }
 
   public function testJSONEncode() {
     $in = array(
       'example' => "Not Valid UTF8: \x80",
     );
 
     $caught = null;
     try {
       $value = phutil_json_encode($in);
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue(($caught instanceof Exception));
   }
 
   public function testHashComparisons() {
     $tests = array(
       array('1', '12', false),
       array('0', '0e123', false),
       array('0e123', '0e124', false),
       array('', '0', false),
       array('000', '0e0', false),
       array('001', '002', false),
       array('0', '', false),
       array('987654321', '123456789', false),
       array('A', 'a', false),
       array('123456789', '123456789', true),
       array('hunter42', 'hunter42', true),
     );
 
     foreach ($tests as $key => $test) {
       list($u, $v, $expect) = $test;
       $actual = phutil_hashes_are_identical($u, $v);
       $this->assertEqual(
         $expect,
         $actual,
         pht('Test Case: "%s" vs "%s"', $u, $v));
     }
   }
 
   public function testVectorSortInt() {
     $original = array(
       ~PHP_INT_MAX,
       -2147483648,
       -5,
       -3,
       -1,
       0,
       1,
       2,
       3,
       100,
       PHP_INT_MAX,
     );
 
     $items = $this->shuffleMap($original);
 
     foreach ($items as $key => $value) {
       $items[$key] = (string)id(new PhutilSortVector())
         ->addInt($value);
     }
 
     asort($items, SORT_STRING);
 
     $this->assertEqual(
       array_keys($original),
       array_keys($items));
   }
 
   public function testVectorSortString() {
     $original = array(
       '',
       "\1",
       'A',
       'AB',
       'Z',
       "Z\1",
       'ZZZ',
     );
 
     $items = $this->shuffleMap($original);
 
     foreach ($items as $key => $value) {
       $items[$key] = (string)id(new PhutilSortVector())
         ->addString($value);
     }
 
     asort($items, SORT_STRING);
 
     $this->assertEqual(
       array_keys($original),
       array_keys($items));
   }
 
   private function shuffleMap(array $map) {
     $keys = array_keys($map);
     shuffle($keys);
     return array_select_keys($map, $keys);
   }
 
   public function testQueryStringEncoding() {
     $expect = array();
 
     // As a starting point, we expect every character to encode as an "%XX"
     // escaped version.
     foreach (range(0, 255) as $byte) {
       $c = chr($byte);
       $expect[$c] = sprintf('%%%02X', $byte);
     }
 
     // We expect these characters to not be escaped.
     $ranges = array(
       range('a', 'z'),
       range('A', 'Z'),
       range('0', '9'),
       array('-', '.', '_', '~'),
     );
 
     foreach ($ranges as $range) {
       foreach ($range as $preserve_char) {
         $expect[$preserve_char] = $preserve_char;
       }
     }
 
     foreach (range(0, 255) as $byte) {
       $c = chr($byte);
 
       $expect_c = $expect[$c];
       $expect_str = "{$expect_c}={$expect_c}";
 
       $actual_str = phutil_build_http_querystring(array($c => $c));
 
       $this->assertEqual(
         $expect_str,
         $actual_str,
         pht('HTTP querystring for byte "%s".', sprintf('0x%02x', $byte)));
     }
   }
 
   public function testNaturalList() {
     $cases = array(
       array(true, array()),
       array(true, array(0 => true, 1 => true, 2 => true)),
       array(true, array('a', 'b', 'c')),
       array(false, array(0 => true, 2 => true, 1 => true)),
       array(false, array(1 => true)),
       array(false, array('sound' => 'quack')),
     );
 
     foreach ($cases as $case) {
       list($expect, $value) = $case;
       $this->assertEqual($expect, phutil_is_natural_list($value));
     }
   }
 
-
 }
diff --git a/src/utils/utf8.php b/src/utils/utf8.php
index 6f8af083..7aff7f76 100644
--- a/src/utils/utf8.php
+++ b/src/utils/utf8.php
@@ -1,950 +1,978 @@
 <?php
 
 /**
  * Convert a string into valid UTF-8. This function is quite slow.
  *
  * When invalid byte subsequences are encountered, they will be replaced with
  * U+FFFD, the Unicode replacement character.
  *
  * This function treats overlong encodings as invalid.
  *
  * @param   string  String to convert to valid UTF-8.
  * @return  string  String with invalid UTF-8 byte subsequences replaced with
  *                  U+FFFD.
  */
 function phutil_utf8ize($string) {
   if (phutil_is_utf8($string)) {
     return $string;
   }
 
   // There is no function to do this in iconv, mbstring or ICU to do this, so
   // do it (very very slowly) in pure PHP.
 
   // TODO: Provide an optional fast C implementation ala fb_utf8ize() if this
   // ever shows up in profiles?
 
   $result = array();
 
   $regex =
     "/([\x01-\x7F]".
       "|[\xC2-\xDF][\x80-\xBF]".
       "|[\xE0][\xA0-\xBF][\x80-\xBF]".
       "|[\xE1-\xEF][\x80-\xBF][\x80-\xBF]".
       "|[\xF0][\x90-\xBF][\x80-\xBF][\x80-\xBF]".
       "|[\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]".
       "|[\xF4][\x80-\x8F][\x80-\xBF][\x80-\xBF])".
     "|(.)/";
 
   $replacement = "\xEF\xBF\xBD";
 
   $offset = 0;
   $matches = null;
   while (preg_match($regex, $string, $matches, 0, $offset)) {
     if (!isset($matches[2])) {
       $match = $matches[1];
 
       if ($match[0] == "\xED") {
         // If this is a 3-byte character that may be part of one of the
         // surrogate ranges, check if it's actually in those ranges. Reject
         // it as invalid if it is. These sequences are used in UTF16 and
         // functions like json_encode() refuse to encode them.
 
         $codepoint = ((ord($match[0]) & 0x0F) << 12)
                    + ((ord($match[1]) & 0x3F) << 6)
                    + ((ord($match[2]) & 0x3F));
         if ($codepoint >= 0xD800 && $codepoint <= 0xDFFF) {
           $result[] = str_repeat($replacement, strlen($match));
           $offset += strlen($matches[0]);
           continue;
         }
       }
 
       $result[] = $match;
     } else {
       // Unicode replacement character, U+FFFD.
       $result[] = $replacement;
     }
 
     $offset += strlen($matches[0]);
   }
 
   return implode('', $result);
 }
 
 
 /**
  * Determine if a string is valid UTF-8, with only basic multilingual plane
  * characters. This is particularly important because MySQL's `utf8` column
  * types silently truncate strings which contain characters outside of this
  * set.
  *
  * @param string  String to test for being valid UTF-8 with only characters in
  *                the basic multilingual plane.
  * @return bool   True if the string is valid UTF-8 with only BMP characters.
  */
 function phutil_is_utf8_with_only_bmp_characters($string) {
   return phutil_is_utf8_slowly($string, $only_bmp = true);
 }
 
 
 /**
  * Determine if a string is valid UTF-8.
  *
  * @param string  Some string which may or may not be valid UTF-8.
  * @return bool    True if the string is valid UTF-8.
  */
 function phutil_is_utf8($string) {
   if (function_exists('mb_check_encoding')) {
     // If mbstring is available, this is significantly faster than using PHP.
     return mb_check_encoding($string, 'UTF-8');
   }
 
   return phutil_is_utf8_slowly($string);
 }
 
 
 /**
  * Determine if a string is valid UTF-8, slowly.
  *
  * This works on any system, but has very poor performance.
  *
  * You should call @{function:phutil_is_utf8} instead of this function, as
  * that function can use more performant mechanisms if they are available on
  * the system.
  *
  * @param string  Some string which may or may not be valid UTF-8.
  * @param bool    True to require all characters be part of the basic
  *                multilingual plane (no more than 3-bytes long).
  * @return bool   True if the string is valid UTF-8.
  */
 function phutil_is_utf8_slowly($string, $only_bmp = false) {
   // First, check the common case of normal ASCII strings. We're fine if
   // the string contains no bytes larger than 127.
   if (preg_match('/^[\x01-\x7F]+\z/', $string)) {
     return true;
   }
 
   // NOTE: In the past, we used a large regular expression in the form of
   // '(x|y|z)+' to match UTF8 strings. However, PCRE can segfaults on patterns
   // like this at relatively small input sizes, at least on some systems
   // (observed on OSX and Windows). This is apparently because the internal
   // implementation is recursive and it blows the stack.
 
   // See <https://bugs.php.net/bug.php?id=45735> for some discussion. Since the
   // input limit is extremely low (less than 50KB on my system), do this check
   // very very slowly in PHP instead. See also T5316.
 
   $len = strlen($string);
   for ($ii = 0; $ii < $len; $ii++) {
     $chr = ord($string[$ii]);
     if ($chr >= 0x01 && $chr <= 0x7F) {
       continue;
     } else if ($chr >= 0xC2 && $chr <= 0xDF) {
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
       if ($chr >= 0x80 && $chr <= 0xBF) {
         continue;
       }
       return false;
+    } else if ($chr == 0xED) {
+      // See T11525. Some sequences in this block are surrogate codepoints
+      // that are reserved for use in UTF16. We should reject them.
+      $codepoint = ($chr & 0x0F) << 12;
+      ++$ii;
+      if ($ii >= $len) {
+        return false;
+      }
+      $chr = ord($string[$ii]);
+      $codepoint += ($chr & 0x3F) << 6;
+      if ($chr >= 0x80 && $chr <= 0xBF) {
+        ++$ii;
+        if ($ii >= $len) {
+          return false;
+        }
+        $chr = ord($string[$ii]);
+        $codepoint += ($chr & 0x3F);
+
+        if ($codepoint >= 0xD800 && $codepoint <= 0xDFFF) {
+          // Reject these surrogate codepoints.
+          return false;
+        }
+
+        if ($chr >= 0x80 && $chr <= 0xBF) {
+          continue;
+        }
+      }
+      return false;
     } else if ($chr > 0xE0 && $chr <= 0xEF) {
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
       if ($chr >= 0x80 && $chr <= 0xBF) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         if ($chr >= 0x80 && $chr <= 0xBF) {
           continue;
         }
       }
       return false;
     } else if ($chr == 0xE0) {
       ++$ii;
       if ($ii >= $len) {
         return false;
       }
       $chr = ord($string[$ii]);
 
       // NOTE: This range starts at 0xA0, not 0x80. The values 0x80-0xA0 are
       // "valid", but not minimal representations, and MySQL rejects them. We're
       // special casing this part of the range.
 
       if ($chr >= 0xA0 && $chr <= 0xBF) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         if ($chr >= 0x80 && $chr <= 0xBF) {
           continue;
         }
       }
       return false;
     } else if (!$only_bmp) {
       if ($chr > 0xF0 && $chr <= 0xF4) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
         if ($chr >= 0x80 && $chr <= 0xBF) {
           ++$ii;
           if ($ii >= $len) {
             return false;
           }
           $chr = ord($string[$ii]);
           if ($chr >= 0x80 && $chr <= 0xBF) {
             ++$ii;
             if ($ii >= $len) {
               return false;
             }
             $chr = ord($string[$ii]);
             if ($chr >= 0x80 && $chr <= 0xBF) {
               continue;
             }
           }
         }
       } else if ($chr == 0xF0) {
         ++$ii;
         if ($ii >= $len) {
           return false;
         }
         $chr = ord($string[$ii]);
 
         // NOTE: As above, this range starts at 0x90, not 0x80. The values
         // 0x80-0x90 are not minimal representations.
 
         if ($chr >= 0x90 && $chr <= 0xBF) {
           ++$ii;
           if ($ii >= $len) {
             return false;
           }
           $chr = ord($string[$ii]);
           if ($chr >= 0x80 && $chr <= 0xBF) {
             ++$ii;
             if ($ii >= $len) {
               return false;
             }
             $chr = ord($string[$ii]);
             if ($chr >= 0x80 && $chr <= 0xBF) {
               continue;
             }
           }
         }
       }
     }
 
     return false;
   }
 
   return true;
 }
 
 
 /**
  * Find the character length of a UTF-8 string.
  *
  * @param string A valid utf-8 string.
  * @return int   The character length of the string.
  */
 function phutil_utf8_strlen($string) {
   if (function_exists('utf8_decode')) {
     return strlen(utf8_decode($string));
   }
   return count(phutil_utf8v($string));
 }
 
 
 /**
  * Find the console display length of a UTF-8 string. This may differ from the
  * character length of the string if it contains double-width characters, like
  * many Chinese characters.
  *
  * This method is based on a C implementation here, which is based on the IEEE
  * standards. The source has more discussion and addresses more considerations
  * than this implementation does.
  *
  *   http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
  *
  * NOTE: We currently assume width 1 for East-Asian ambiguous characters.
  *
  * NOTE: This function is VERY slow.
  *
  * @param   string  A valid UTF-8 string.
  * @return  int     The console display length of the string.
  */
 function phutil_utf8_console_strlen($string) {
   // Formatting and colors don't contribute any width in the console.
   $string = preg_replace("/\x1B\[\d*m/", '', $string);
 
   // In the common case of an ASCII string, just return the string length.
   if (preg_match('/^[\x01-\x7F]*\z/', $string)) {
     return strlen($string);
   }
 
   $len = 0;
 
   // NOTE: To deal with combining characters, we're splitting the string into
   // glyphs first (characters with combiners) and then counting just the width
   // of the first character in each glyph.
 
   $display_glyphs = phutil_utf8v_combined($string);
   foreach ($display_glyphs as $display_glyph) {
     $glyph_codepoints = phutil_utf8v_codepoints($display_glyph);
     foreach ($glyph_codepoints as $c) {
       if ($c == 0) {
         break;
       }
 
       $len += 1 +
         ($c >= 0x1100 &&
           ($c <= 0x115F ||                    /* Hangul Jamo init. consonants */
             $c == 0x2329 || $c == 0x232A ||
             ($c >= 0x2E80 && $c <= 0xA4CF &&
               $c != 0x303F) ||                  /* CJK ... Yi */
             ($c >= 0xAC00 && $c <= 0xD7A3) || /* Hangul Syllables */
             ($c >= 0xF900 && $c <= 0xFAFF) || /* CJK Compatibility Ideographs */
             ($c >= 0xFE10 && $c <= 0xFE19) || /* Vertical forms */
             ($c >= 0xFE30 && $c <= 0xFE6F) || /* CJK Compatibility Forms */
             ($c >= 0xFF00 && $c <= 0xFF60) || /* Fullwidth Forms */
             ($c >= 0xFFE0 && $c <= 0xFFE6) ||
             ($c >= 0x20000 && $c <= 0x2FFFD) ||
             ($c >= 0x30000 && $c <= 0x3FFFD)));
 
       break;
     }
   }
 
   return $len;
 }
 
 
 /**
  * Test if a string contains Chinese, Japanese, or Korean characters.
  *
  * Most languages use spaces to separate words, but these languages do not.
  *
  * @param string String to examine, in UTF8.
  * @return bool True if the string contains Chinese, Japanese, or Korean
  *   characters.
  */
 function phutil_utf8_is_cjk($string) {
   $codepoints = phutil_utf8v_codepoints($string);
 
   foreach ($codepoints as $codepoint) {
     // CJK Unified Ideographs
     if ($codepoint >= 0x4E00 && $codepoint <= 0x9FFF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension A
     if ($codepoint >= 0x3400 && $codepoint <= 0x4DBF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension B
     if ($codepoint >= 0x20000 && $codepoint <= 0x2A6DF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension C
     if ($codepoint >= 0x2A700 && $codepoint <= 0x2B73F) {
       return true;
     }
 
     // CJK Unified Ideographs Extension D
     if ($codepoint >= 0x2B740 && $codepoint <= 0x2B81F) {
       return true;
     }
 
     // CJK Unified Ideographs Extension E
     if ($codepoint >= 0x2B820 && $codepoint <= 0x2CEAF) {
       return true;
     }
 
     // CJK Unified Ideographs Extension F
     if ($codepoint >= 0x2CEB0 && $codepoint <= 0x2EBEF) {
       return true;
     }
 
     // CJK Compatibility Ideographs
     if ($codepoint >= 0xF900 && $codepoint <= 0xFAFF) {
       return true;
     }
   }
 
   return false;
 }
 
 
 /**
  * Split a UTF-8 string into an array of characters. Combining characters are
  * also split.
  *
  * @param string A valid utf-8 string.
  * @param int|null Stop processing after examining this many bytes.
  * @return list  A list of characters in the string.
  */
 function phutil_utf8v($string, $byte_limit = null) {
   $res = array();
   $len = strlen($string);
 
   $ii = 0;
   while ($ii < $len) {
     $byte = $string[$ii];
     if ($byte <= "\x7F") {
       $res[] = $byte;
       $ii += 1;
 
       if ($byte_limit && ($ii >= $byte_limit)) {
         break;
       }
 
       continue;
     } else if ($byte < "\xC0") {
       throw new Exception(
         pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
     } else if ($byte <= "\xDF") {
       $seq_len = 2;
     } else if ($byte <= "\xEF") {
       $seq_len = 3;
     } else if ($byte <= "\xF7") {
       $seq_len = 4;
     } else if ($byte <= "\xFB") {
       $seq_len = 5;
     } else if ($byte <= "\xFD") {
       $seq_len = 6;
     } else {
       throw new Exception(
         pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
     }
 
     if ($ii + $seq_len > $len) {
       throw new Exception(
         pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
     }
     for ($jj = 1; $jj < $seq_len; ++$jj) {
       if ($string[$ii + $jj] >= "\xC0") {
         throw new Exception(
           pht('Invalid UTF-8 string passed to %s.', __FUNCTION__));
       }
     }
     $res[] = substr($string, $ii, $seq_len);
     $ii += $seq_len;
 
     if ($byte_limit && ($ii >= $byte_limit)) {
       break;
     }
   }
 
   return $res;
 }
 
 
 /**
  * Split a UTF-8 string into an array of codepoints (as integers).
  *
  * @param   string  A valid UTF-8 string.
  * @return  list    A list of codepoints, as integers.
  */
 function phutil_utf8v_codepoints($string) {
   $str_v = phutil_utf8v($string);
 
   foreach ($str_v as $key => $char) {
     $c = ord($char[0]);
     $v = 0;
 
     if (($c & 0x80) == 0) {
       $v = $c;
     } else if (($c & 0xE0) == 0xC0) {
       $v = (($c & 0x1F) << 6)
          + ((ord($char[1]) & 0x3F));
     } else if (($c & 0xF0) == 0xE0) {
       $v = (($c & 0x0F) << 12)
          + ((ord($char[1]) & 0x3F) << 6)
          + ((ord($char[2]) & 0x3F));
     } else if (($c & 0xF8) == 0xF0) {
       $v = (($c & 0x07) << 18)
          + ((ord($char[1]) & 0x3F) << 12)
          + ((ord($char[2]) & 0x3F) << 6)
          + ((ord($char[3]) & 0x3F));
     } else if (($c & 0xFC) == 0xF8) {
       $v = (($c & 0x03) << 24)
          + ((ord($char[1]) & 0x3F) << 18)
          + ((ord($char[2]) & 0x3F) << 12)
          + ((ord($char[3]) & 0x3F) << 6)
          + ((ord($char[4]) & 0x3F));
     } else if (($c & 0xFE) == 0xFC) {
       $v = (($c & 0x01) << 30)
          + ((ord($char[1]) & 0x3F) << 24)
          + ((ord($char[2]) & 0x3F) << 18)
          + ((ord($char[3]) & 0x3F) << 12)
          + ((ord($char[4]) & 0x3F) << 6)
          + ((ord($char[5]) & 0x3F));
     }
 
     $str_v[$key] = $v;
   }
 
   return $str_v;
 }
 
 
 /**
  * Convert a Unicode codepoint into a UTF8-encoded string.
  *
  * @param int Unicode codepoint.
  * @return string UTF8 encoding.
  */
 function phutil_utf8_encode_codepoint($codepoint) {
   if ($codepoint < 0x80) {
     $r = chr($codepoint);
   } else if ($codepoint < 0x800) {
     $r = chr(0xC0 | (($codepoint >> 6)  & 0x1F)).
          chr(0x80 | (($codepoint)       & 0x3F));
   } else if ($codepoint < 0x10000) {
     $r = chr(0xE0 | (($codepoint >> 12) & 0x0F)).
          chr(0x80 | (($codepoint >> 6)  & 0x3F)).
          chr(0x80 | (($codepoint)       & 0x3F));
   } else if ($codepoint < 0x110000) {
     $r = chr(0xF0 | (($codepoint >> 18) & 0x07)).
          chr(0x80 | (($codepoint >> 12) & 0x3F)).
          chr(0x80 | (($codepoint >> 6)  & 0x3F)).
          chr(0x80 | (($codepoint)       & 0x3F));
   } else {
     throw new Exception(
       pht(
         'Encoding UTF8 codepoint "%s" is not supported.',
         $codepoint));
   }
 
   return $r;
 }
 
 
 /**
  * Hard-wrap a block of UTF-8 text with embedded HTML tags and entities.
  *
  * @param   string An HTML string with tags and entities.
  * @return  list   List of hard-wrapped lines.
  */
 function phutil_utf8_hard_wrap_html($string, $width) {
   $break_here = array();
 
   // Convert the UTF-8 string into a list of UTF-8 characters.
   $vector = phutil_utf8v($string);
   $len = count($vector);
   $char_pos = 0;
   for ($ii = 0; $ii < $len; ++$ii) {
     // An ampersand indicates an HTML entity; consume the whole thing (until
     // ";") but treat it all as one character.
     if ($vector[$ii] == '&') {
       do {
         ++$ii;
       } while ($vector[$ii] != ';');
       ++$char_pos;
     // An "<" indicates an HTML tag, consume the whole thing but don't treat
     // it as a character.
     } else if ($vector[$ii] == '<') {
       do {
         ++$ii;
       } while ($vector[$ii] != '>');
     } else {
       ++$char_pos;
     }
 
     // Keep track of where we need to break the string later.
     if ($char_pos == $width) {
       $break_here[$ii] = true;
       $char_pos = 0;
     }
   }
 
   $result = array();
   $string = '';
   foreach ($vector as $ii => $char) {
     $string .= $char;
     if (isset($break_here[$ii])) {
       $result[] = $string;
       $string = '';
     }
   }
 
   if (strlen($string)) {
     $result[] = $string;
   }
 
   return $result;
 }
 
 /**
   * Hard-wrap a block of UTF-8 text with no embedded HTML tags and entities.
   *
   * @param string A non HTML string
   * @param int Width of the hard-wrapped lines
   * @return list List of hard-wrapped lines.
   */
 function phutil_utf8_hard_wrap($string, $width) {
   $result = array();
 
   $lines = phutil_split_lines($string, $retain_endings = false);
   foreach ($lines as $line) {
 
     // Convert the UTF-8 string into a list of UTF-8 characters.
     $vector = phutil_utf8v($line);
 
     $len = count($vector);
     $buffer = '';
 
     for ($ii = 1; $ii <= $len; ++$ii) {
       $buffer .= $vector[$ii - 1];
       if (($ii % $width) === 0) {
         $result[] = $buffer;
         $buffer = '';
       }
     }
 
     if (strlen($buffer)) {
       $result[] = $buffer;
     }
   }
 
   return $result;
 }
 
 /**
  * Convert a string from one encoding (like ISO-8859-1) to another encoding
  * (like UTF-8).
  *
  * This is primarily a thin wrapper around `mb_convert_encoding()` which checks
  * you have the extension installed, since we try to require the extension
  * only if you actually need it (i.e., you want to work with encodings other
  * than UTF-8).
  *
  * NOTE: This function assumes that the input is in the given source encoding.
  * If it is not, it may not output in the specified target encoding. If you
  * need to perform a hard conversion to UTF-8, use this function in conjunction
  * with @{function:phutil_utf8ize}. We can detect failures caused by invalid
  * encoding names, but `mb_convert_encoding()` fails silently if the
  * encoding name identifies a real encoding but the string is not actually
  * encoded with that encoding.
  *
  * @param string String to re-encode.
  * @param string Target encoding name, like "UTF-8".
  * @param string Source encoding name, like "ISO-8859-1".
  * @return string Input string, with converted character encoding.
  *
  * @phutil-external-symbol function mb_convert_encoding
  */
 function phutil_utf8_convert($string, $to_encoding, $from_encoding) {
   if (!$from_encoding) {
     throw new InvalidArgumentException(
       pht(
         'Attempting to convert a string encoding, but no source encoding '.
         'was provided. Explicitly provide the source encoding.'));
   }
   if (!$to_encoding) {
     throw new InvalidArgumentException(
       pht(
         'Attempting to convert a string encoding, but no target encoding '.
         'was provided. Explicitly provide the target encoding.'));
   }
 
   // Normalize encoding names so we can no-op the very common case of UTF8
   // to UTF8 (or any other conversion where both encodings are identical).
   $to_upper = strtoupper(str_replace('-', '', $to_encoding));
   $from_upper = strtoupper(str_replace('-', '', $from_encoding));
   if ($from_upper == $to_upper) {
     return $string;
   }
 
   if (!function_exists('mb_convert_encoding')) {
     throw new Exception(
       pht(
         "Attempting to convert a string encoding from '%s' to '%s', ".
         "but the '%s' PHP extension is not available. Install %s to ".
         "work with encodings other than UTF-8.",
         $from_encoding,
         $to_encoding,
         'mbstring',
         'mbstring'));
   }
 
   $result = @mb_convert_encoding($string, $to_encoding, $from_encoding);
 
   if ($result === false) {
     $message = error_get_last();
     if ($message) {
       $message = idx($message, 'message', pht('Unknown error.'));
     }
     throw new Exception(
       pht(
         "String conversion from encoding '%s' to encoding '%s' failed: %s",
         $from_encoding,
         $to_encoding,
         $message));
   }
 
   return $result;
 }
 
 
 /**
  * Convert a string to title case in a UTF8-aware way. This function doesn't
  * necessarily do a great job, but the builtin implementation of `ucwords()` can
  * completely destroy inputs, so it just has to be better than that. Similar to
  * @{function:ucwords}.
  *
  * @param   string  UTF-8 input string.
  * @return  string  Input, in some semblance of title case.
  */
 function phutil_utf8_ucwords($str) {
   // NOTE: mb_convert_case() discards uppercase letters in words when converting
   // to title case. For example, it will convert "AAA" into "Aaa", which is
   // undesirable.
 
   $v = phutil_utf8v($str);
   $result = '';
   $last = null;
 
   $ord_a = ord('a');
   $ord_z = ord('z');
   foreach ($v as $c) {
     $convert = false;
     if ($last === null || $last === ' ') {
       $o = ord($c[0]);
       if ($o >= $ord_a && $o <= $ord_z) {
         $convert = true;
       }
     }
 
     if ($convert) {
       $result .= phutil_utf8_strtoupper($c);
     } else {
       $result .= $c;
     }
 
     $last = $c;
   }
 
   return $result;
 }
 
 
 /**
  * Convert a string to lower case in a UTF8-aware way. Similar to
  * @{function:strtolower}.
  *
  * @param   string  UTF-8 input string.
  * @return  string  Input, in some semblance of lower case.
  *
  * @phutil-external-symbol function mb_convert_case
  */
 function phutil_utf8_strtolower($str) {
   if (function_exists('mb_convert_case')) {
     return mb_convert_case($str, MB_CASE_LOWER, 'UTF-8');
   }
 
   static $map;
   if ($map === null) {
     $map = array_combine(
       range('A', 'Z'),
       range('a', 'z'));
   }
 
   return phutil_utf8_strtr($str, $map);
 }
 
 
 /**
  * Convert a string to upper case in a UTF8-aware way. Similar to
  * @{function:strtoupper}.
  *
  * @param   string  UTF-8 input string.
  * @return  string  Input, in some semblance of upper case.
  *
  * @phutil-external-symbol function mb_convert_case
  */
 function phutil_utf8_strtoupper($str) {
   if (function_exists('mb_convert_case')) {
     return mb_convert_case($str, MB_CASE_UPPER, 'UTF-8');
   }
 
   static $map;
   if ($map === null) {
     $map = array_combine(
       range('a', 'z'),
       range('A', 'Z'));
   }
 
   return phutil_utf8_strtr($str, $map);
 }
 
 
 /**
  * Replace characters in a string in a UTF-aware way. Similar to
  * @{function:strtr}.
  *
  * @param   string              UTF-8 input string.
  * @param   map<string, string> Map of characters to replace.
  * @return  string              Input with translated characters.
  */
 function phutil_utf8_strtr($str, array $map) {
   $v = phutil_utf8v($str);
   $result = '';
   foreach ($v as $c) {
     if (isset($map[$c])) {
       $result .= $map[$c];
     } else {
       $result .= $c;
     }
   }
 
   return $result;
 }
 
 /**
  * Determine if a given unicode character is a combining character or not.
  *
  * @param   string              A single unicode character.
  * @return  boolean             True or false.
  */
 function phutil_utf8_is_combining_character($character) {
   $components = phutil_utf8v_codepoints($character);
 
   // Combining Diacritical Marks (0300 - 036F).
   // Combining Diacritical Marks Supplement (1DC0 - 1DFF).
   // Combining Diacritical Marks for Symbols (20D0 - 20FF).
   // Combining Half Marks (FE20 - FE2F).
 
   foreach ($components as $codepoint) {
     if ($codepoint >= 0x0300 && $codepoint <= 0x036F ||
          $codepoint >= 0x1DC0 && $codepoint <= 0x1DFF ||
          $codepoint >= 0x20D0 && $codepoint <= 0x20FF ||
          $codepoint >= 0xFE20 && $codepoint <= 0xFE2F) {
       return true;
     }
   }
 
   return false;
 }
 
 
 /**
  * Split a UTF-8 string into an array of characters. Combining characters
  * are not split.
  *
  * @param string A valid utf-8 string.
  * @return list  A list of characters in the string.
  */
 function phutil_utf8v_combined($string) {
   $components = phutil_utf8v($string);
   return phutil_utf8v_combine_characters($components);
 }
 
 
 /**
  * Merge combining characters in a UTF-8 string.
  *
  * This is a low-level method which can allow other operations to do less work.
  * If you have a string, call @{method:phutil_utf8v_combined} instead.
  *
  * @param list List of UTF-8 characters.
  * @return list List of UTF-8 strings with combining characters merged.
  */
 function phutil_utf8v_combine_characters(array $characters) {
   if (!$characters) {
     return array();
   }
 
   // If the first character in the string is a combining character,
   // start with a space.
   if (phutil_utf8_is_combining_character($characters[0])) {
     $buf = ' ';
   } else {
     $buf = null;
   }
 
   $parts = array();
   foreach ($characters as $character) {
     if (!isset($character[1])) {
       // This an optimization: there are no one-byte combining characters,
       // so we can just pass these through unmodified.
       $is_combining = false;
     } else {
       $is_combining = phutil_utf8_is_combining_character($character);
     }
 
     if ($is_combining) {
       $buf .= $character;
     } else {
       if ($buf !== null) {
         $parts[] = $buf;
       }
       $buf = $character;
     }
   }
 
   $parts[] = $buf;
 
   return $parts;
 }
 
 
 /**
  * Return the current system locale setting (LC_ALL).
  *
  * @return string Current system locale setting.
  */
 function phutil_get_system_locale() {
   $locale = setlocale(LC_ALL, 0);
 
   if ($locale === false) {
     throw new Exception(
       pht(
         'Unable to determine current system locale (call to '.
         '"setlocale(LC_ALL, 0)" failed).'));
   }
 
   return $locale;
 }
 
 
 /**
  * Test if a system locale (LC_ALL) is available on the system.
  *
  * @param string Locale name like "en_US.UTF-8".
  * @return bool True if the locale is available.
  */
 function phutil_is_system_locale_available($locale) {
   $old_locale = phutil_get_system_locale();
   $is_available = @setlocale(LC_ALL, $locale);
   setlocale(LC_ALL, $old_locale);
 
   return ($is_available !== false);
 }
 
 
 /**
  * Set the system locale (LC_ALL) to a particular value.
  *
  * @param string New locale setting.
  * @return void
  */
 function phutil_set_system_locale($locale) {
   $ok = @setlocale(LC_ALL, $locale);
   if (!$ok) {
     throw new Exception(
       pht(
         'Failed to set system locale (to "%s").',
         $locale));
   }
 }
diff --git a/src/utils/utils.php b/src/utils/utils.php
index 30a3afc8..495749c5 100644
--- a/src/utils/utils.php
+++ b/src/utils/utils.php
@@ -1,1920 +1,1920 @@
 <?php
 
 /**
  * Identity function, returns its argument unmodified.
  *
  * This is useful almost exclusively as a workaround to an oddity in the PHP
  * grammar -- this is a syntax error:
  *
  *    COUNTEREXAMPLE
  *    new Thing()->doStuff();
  *
  * ...but this works fine:
  *
  *    id(new Thing())->doStuff();
  *
  * @param   wild Anything.
  * @return  wild Unmodified argument.
  */
 function id($x) {
   return $x;
 }
 
 
 /**
  * Access an array index, retrieving the value stored there if it exists or
  * a default if it does not. This function allows you to concisely access an
  * index which may or may not exist without raising a warning.
  *
  * @param   array   Array to access.
  * @param   scalar  Index to access in the array.
  * @param   wild    Default value to return if the key is not present in the
  *                  array.
  * @return  wild    If `$array[$key]` exists, that value is returned. If not,
  *                  $default is returned without raising a warning.
  */
 function idx(array $array, $key, $default = null) {
   // isset() is a micro-optimization - it is fast but fails for null values.
   if (isset($array[$key])) {
     return $array[$key];
   }
 
   // Comparing $default is also a micro-optimization.
   if ($default === null || array_key_exists($key, $array)) {
     return null;
   }
 
   return $default;
 }
 
 
 /**
  * Access a sequence of array indexes, retrieving a deeply nested value if
  * it exists or a default if it does not.
  *
  * For example, `idxv($dict, array('a', 'b', 'c'))` accesses the key at
  * `$dict['a']['b']['c']`, if it exists. If it does not, or any intermediate
  * value is not itself an array, it returns the defualt value.
  *
  * @param array Array to access.
  * @param list<string> List of keys to access, in sequence.
  * @param wild Default value to return.
  * @return wild Accessed value, or default if the value is not accessible.
  */
 function idxv(array $map, array $path, $default = null) {
   if (!$path) {
     return $default;
   }
 
   $last = last($path);
   $path = array_slice($path, 0, -1);
 
   $cursor = $map;
   foreach ($path as $key) {
     $cursor = idx($cursor, $key);
     if (!is_array($cursor)) {
       return $default;
     }
   }
 
   return idx($cursor, $last, $default);
 }
 
 
 /**
  * Call a method on a list of objects. Short for "method pull", this function
  * works just like @{function:ipull}, except that it operates on a list of
  * objects instead of a list of arrays. This function simplifies a common type
  * of mapping operation:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $key => $object) {
  *      $names[$key] = $object->getName();
  *    }
  *
  * You can express this more concisely with mpull():
  *
  *    $names = mpull($objects, 'getName');
  *
  * mpull() takes a third argument, which allows you to do the same but for
  * the array's keys:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $object) {
  *      $names[$object->getID()] = $object->getName();
  *    }
  *
  * This is the mpull version():
  *
  *    $names = mpull($objects, 'getName', 'getID');
  *
  * If you pass ##null## as the second argument, the objects will be preserved:
  *
  *    COUNTEREXAMPLE
  *    $id_map = array();
  *    foreach ($objects as $object) {
  *      $id_map[$object->getID()] = $object;
  *    }
  *
  * With mpull():
  *
  *    $id_map = mpull($objects, null, 'getID');
  *
  * See also @{function:ipull}, which works similarly but accesses array indexes
  * instead of calling methods.
  *
  * @param   list          Some list of objects.
  * @param   string|null   Determines which **values** will appear in the result
  *                        array. Use a string like 'getName' to store the
  *                        value of calling the named method in each value, or
  *                        ##null## to preserve the original objects.
  * @param   string|null   Determines how **keys** will be assigned in the result
  *                        array. Use a string like 'getID' to use the result
  *                        of calling the named method as each object's key, or
  *                        `null` to preserve the original keys.
  * @return  dict          A dictionary with keys and values derived according
  *                        to whatever you passed as `$method` and `$key_method`.
  */
 function mpull(array $list, $method, $key_method = null) {
   $result = array();
   foreach ($list as $key => $object) {
     if ($key_method !== null) {
       $key = $object->$key_method();
     }
     if ($method !== null) {
       $value = $object->$method();
     } else {
       $value = $object;
     }
     $result[$key] = $value;
   }
   return $result;
 }
 
 
 /**
  * Access a property on a list of objects. Short for "property pull", this
  * function works just like @{function:mpull}, except that it accesses object
  * properties instead of methods. This function simplifies a common type of
  * mapping operation:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $key => $object) {
  *      $names[$key] = $object->name;
  *    }
  *
  * You can express this more concisely with ppull():
  *
  *    $names = ppull($objects, 'name');
  *
  * ppull() takes a third argument, which allows you to do the same but for
  * the array's keys:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($objects as $object) {
  *      $names[$object->id] = $object->name;
  *    }
  *
  * This is the ppull version():
  *
  *    $names = ppull($objects, 'name', 'id');
  *
  * If you pass ##null## as the second argument, the objects will be preserved:
  *
  *    COUNTEREXAMPLE
  *    $id_map = array();
  *    foreach ($objects as $object) {
  *      $id_map[$object->id] = $object;
  *    }
  *
  * With ppull():
  *
  *    $id_map = ppull($objects, null, 'id');
  *
  * See also @{function:mpull}, which works similarly but calls object methods
  * instead of accessing object properties.
  *
  * @param   list          Some list of objects.
  * @param   string|null   Determines which **values** will appear in the result
  *                        array. Use a string like 'name' to store the value of
  *                        accessing the named property in each value, or
  *                        `null` to preserve the original objects.
  * @param   string|null   Determines how **keys** will be assigned in the result
  *                        array. Use a string like 'id' to use the result of
  *                        accessing the named property as each object's key, or
  *                        `null` to preserve the original keys.
  * @return  dict          A dictionary with keys and values derived according
  *                        to whatever you passed as `$property` and
  *                        `$key_property`.
  */
 function ppull(array $list, $property, $key_property = null) {
   $result = array();
   foreach ($list as $key => $object) {
     if ($key_property !== null) {
       $key = $object->$key_property;
     }
     if ($property !== null) {
       $value = $object->$property;
     } else {
       $value = $object;
     }
     $result[$key] = $value;
   }
   return $result;
 }
 
 
 /**
  * Choose an index from a list of arrays. Short for "index pull", this function
  * works just like @{function:mpull}, except that it operates on a list of
  * arrays and selects an index from them instead of operating on a list of
  * objects and calling a method on them.
  *
  * This function simplifies a common type of mapping operation:
  *
  *    COUNTEREXAMPLE
  *    $names = array();
  *    foreach ($list as $key => $dict) {
  *      $names[$key] = $dict['name'];
  *    }
  *
  * With ipull():
  *
  *    $names = ipull($list, 'name');
  *
  * See @{function:mpull} for more usage examples.
  *
  * @param   list          Some list of arrays.
  * @param   scalar|null   Determines which **values** will appear in the result
  *                        array. Use a scalar to select that index from each
  *                        array, or null to preserve the arrays unmodified as
  *                        values.
  * @param   scalar|null   Determines which **keys** will appear in the result
  *                        array. Use a scalar to select that index from each
  *                        array, or null to preserve the array keys.
  * @return  dict          A dictionary with keys and values derived according
  *                        to whatever you passed for `$index` and `$key_index`.
  */
 function ipull(array $list, $index, $key_index = null) {
   $result = array();
   foreach ($list as $key => $array) {
     if ($key_index !== null) {
       $key = $array[$key_index];
     }
     if ($index !== null) {
       $value = $array[$index];
     } else {
       $value = $array;
     }
     $result[$key] = $value;
   }
   return $result;
 }
 
 
 /**
  * Group a list of objects by the result of some method, similar to how
  * GROUP BY works in an SQL query. This function simplifies grouping objects
  * by some property:
  *
  *    COUNTEREXAMPLE
  *    $animals_by_species = array();
  *    foreach ($animals as $animal) {
  *      $animals_by_species[$animal->getSpecies()][] = $animal;
  *    }
  *
  * This can be expressed more tersely with mgroup():
  *
  *    $animals_by_species = mgroup($animals, 'getSpecies');
  *
  * In either case, the result is a dictionary which maps species (e.g., like
  * "dog") to lists of animals with that property, so all the dogs are grouped
  * together and all the cats are grouped together, or whatever super
  * businessesey thing is actually happening in your problem domain.
  *
  * See also @{function:igroup}, which works the same way but operates on
  * array indexes.
  *
  * @param   list    List of objects to group by some property.
  * @param   string  Name of a method, like 'getType', to call on each object
  *                  in order to determine which group it should be placed into.
  * @param   ...     Zero or more additional method names, to subgroup the
  *                  groups.
  * @return  dict    Dictionary mapping distinct method returns to lists of
  *                  all objects which returned that value.
  */
 function mgroup(array $list, $by /* , ... */) {
   $map = mpull($list, $by);
 
   $groups = array();
   foreach ($map as $group) {
     // Can't array_fill_keys() here because 'false' gets encoded wrong.
     $groups[$group] = array();
   }
 
   foreach ($map as $key => $group) {
     $groups[$group][$key] = $list[$key];
   }
 
   $args = func_get_args();
   $args = array_slice($args, 2);
   if ($args) {
     array_unshift($args, null);
     foreach ($groups as $group_key => $grouped) {
       $args[0] = $grouped;
       $groups[$group_key] = call_user_func_array('mgroup', $args);
     }
   }
 
   return $groups;
 }
 
 
 /**
  * Group a list of arrays by the value of some index. This function is the same
  * as @{function:mgroup}, except it operates on the values of array indexes
  * rather than the return values of method calls.
  *
  * @param   list    List of arrays to group by some index value.
  * @param   string  Name of an index to select from each array in order to
  *                  determine which group it should be placed into.
  * @param   ...     Zero or more additional indexes names, to subgroup the
  *                  groups.
  * @return  dict    Dictionary mapping distinct index values to lists of
  *                  all objects which had that value at the index.
  */
 function igroup(array $list, $by /* , ... */) {
   $map = ipull($list, $by);
 
   $groups = array();
   foreach ($map as $group) {
     $groups[$group] = array();
   }
 
   foreach ($map as $key => $group) {
     $groups[$group][$key] = $list[$key];
   }
 
   $args = func_get_args();
   $args = array_slice($args, 2);
   if ($args) {
     array_unshift($args, null);
     foreach ($groups as $group_key => $grouped) {
       $args[0] = $grouped;
       $groups[$group_key] = call_user_func_array('igroup', $args);
     }
   }
 
   return $groups;
 }
 
 
 /**
  * Sort a list of objects by the return value of some method. In PHP, this is
  * often vastly more efficient than `usort()` and similar.
  *
  *    // Sort a list of Duck objects by name.
  *    $sorted = msort($ducks, 'getName');
  *
  * It is usually significantly more efficient to define an ordering method
  * on objects and call `msort()` than to write a comparator. It is often more
  * convenient, as well.
  *
  * NOTE: This method does not take the list by reference; it returns a new list.
  *
  * @param   list    List of objects to sort by some property.
  * @param   string  Name of a method to call on each object; the return values
  *                  will be used to sort the list.
  * @return  list    Objects ordered by the return values of the method calls.
  */
 function msort(array $list, $method) {
   $surrogate = mpull($list, $method);
 
   // See T13303. A "PhutilSortVector" is technically a sortable object, so
   // a method which returns a "PhutilSortVector" is suitable for use with
   // "msort()". However, it's almost certain that the caller intended to use
   // "msortv()", not "msort()", and forgot to add a "v". Treat this as an error.
 
   if ($surrogate) {
     $item = head($surrogate);
     if ($item instanceof PhutilSortVector) {
       throw new Exception(
         pht(
           'msort() was passed a method ("%s") which returns '.
           '"PhutilSortVector" objects. Use "msortv()", not "msort()", to '.
           'sort a list which produces vectors.',
           $method));
     }
   }
 
   asort($surrogate);
 
   $result = array();
   foreach ($surrogate as $key => $value) {
     $result[$key] = $list[$key];
   }
 
   return $result;
 }
 
 
 /**
  * Sort a list of objects by a sort vector.
  *
  * This sort is stable, well-behaved, and more efficient than `usort()`.
  *
  * @param list List of objects to sort.
  * @param string Name of a method to call on each object. The method must
  *   return a @{class:PhutilSortVector}.
  * @return list Objects ordered by the vectors.
  */
 function msortv(array $list, $method) {
   $surrogate = mpull($list, $method);
 
   $index = 0;
   foreach ($surrogate as $key => $value) {
     if (!($value instanceof PhutilSortVector)) {
       throw new Exception(
         pht(
           'Objects passed to "%s" must return sort vectors (objects of '.
           'class "%s") from the specified method ("%s"). One object (with '.
           'key "%s") did not.',
           'msortv()',
           'PhutilSortVector',
           $method,
           $key));
     }
 
     // Add the original index to keep the sort stable.
     $value->addInt($index++);
 
     $surrogate[$key] = (string)$value;
   }
 
   asort($surrogate, SORT_STRING);
 
   $result = array();
   foreach ($surrogate as $key => $value) {
     $result[$key] = $list[$key];
   }
 
   return $result;
 }
 
 
 /**
  * Sort a list of arrays by the value of some index. This method is identical to
  * @{function:msort}, but operates on a list of arrays instead of a list of
  * objects.
  *
  * @param   list    List of arrays to sort by some index value.
  * @param   string  Index to access on each object; the return values
  *                  will be used to sort the list.
  * @return  list    Arrays ordered by the index values.
  */
 function isort(array $list, $index) {
   $surrogate = ipull($list, $index);
 
   asort($surrogate);
 
   $result = array();
   foreach ($surrogate as $key => $value) {
     $result[$key] = $list[$key];
   }
 
   return $result;
 }
 
 
 /**
  * Filter a list of objects by executing a method across all the objects and
  * filter out the ones with empty() results. this function works just like
  * @{function:ifilter}, except that it operates on a list of objects instead
  * of a list of arrays.
  *
  * For example, to remove all objects with no children from a list, where
  * 'hasChildren' is a method name, do this:
  *
  *   mfilter($list, 'hasChildren');
  *
  * The optional third parameter allows you to negate the operation and filter
  * out nonempty objects. To remove all objects that DO have children, do this:
  *
  *   mfilter($list, 'hasChildren', true);
  *
  * @param  array        List of objects to filter.
  * @param  string       A method name.
  * @param  bool         Optionally, pass true to drop objects which pass the
  *                      filter instead of keeping them.
  * @return array        List of objects which pass the filter.
  */
 function mfilter(array $list, $method, $negate = false) {
   if (!is_string($method)) {
     throw new InvalidArgumentException(pht('Argument method is not a string.'));
   }
 
   $result = array();
   foreach ($list as $key => $object) {
     $value = $object->$method();
 
     if (!$negate) {
       if (!empty($value)) {
         $result[$key] = $object;
       }
     } else {
       if (empty($value)) {
         $result[$key] = $object;
       }
     }
   }
 
   return $result;
 }
 
 
 /**
  * Filter a list of arrays by removing the ones with an empty() value for some
  * index. This function works just like @{function:mfilter}, except that it
  * operates on a list of arrays instead of a list of objects.
  *
  * For example, to remove all arrays without value for key 'username', do this:
  *
  *   ifilter($list, 'username');
  *
  * The optional third parameter allows you to negate the operation and filter
  * out nonempty arrays. To remove all arrays that DO have value for key
  * 'username', do this:
  *
  *   ifilter($list, 'username', true);
  *
  * @param  array        List of arrays to filter.
  * @param  scalar       The index.
  * @param  bool         Optionally, pass true to drop arrays which pass the
  *                      filter instead of keeping them.
  * @return array        List of arrays which pass the filter.
  */
 function ifilter(array $list, $index, $negate = false) {
   if (!is_scalar($index)) {
     throw new InvalidArgumentException(pht('Argument index is not a scalar.'));
   }
 
   $result = array();
   if (!$negate) {
     foreach ($list as $key => $array) {
       if (!empty($array[$index])) {
         $result[$key] = $array;
       }
     }
   } else {
     foreach ($list as $key => $array) {
       if (empty($array[$index])) {
         $result[$key] = $array;
       }
     }
   }
 
   return $result;
 }
 
 
 /**
  * Selects a list of keys from an array, returning a new array with only the
  * key-value pairs identified by the selected keys, in the specified order.
  *
  * Note that since this function orders keys in the result according to the
  * order they appear in the list of keys, there are effectively two common
  * uses: either reducing a large dictionary to a smaller one, or changing the
  * key order on an existing dictionary.
  *
  * @param  dict    Dictionary of key-value pairs to select from.
  * @param  list    List of keys to select.
  * @return dict    Dictionary of only those key-value pairs where the key was
  *                 present in the list of keys to select. Ordering is
  *                 determined by the list order.
  */
 function array_select_keys(array $dict, array $keys) {
   $result = array();
   foreach ($keys as $key) {
     if (array_key_exists($key, $dict)) {
       $result[$key] = $dict[$key];
     }
   }
   return $result;
 }
 
 
 /**
  * Checks if all values of array are instances of the passed class. Throws
  * `InvalidArgumentException` if it isn't true for any value.
  *
  * @param  array
  * @param  string  Name of the class or 'array' to check arrays.
  * @return array   Returns passed array.
  */
 function assert_instances_of(array $arr, $class) {
   $is_array = !strcasecmp($class, 'array');
 
   foreach ($arr as $key => $object) {
     if ($is_array) {
       if (!is_array($object)) {
         $given = gettype($object);
         throw new InvalidArgumentException(
           pht(
             "Array item with key '%s' must be of type array, %s given.",
             $key,
             $given));
       }
 
     } else if (!($object instanceof $class)) {
       $given = gettype($object);
       if (is_object($object)) {
         $given = pht('instance of %s', get_class($object));
       }
       throw new InvalidArgumentException(
         pht(
           "Array item with key '%s' must be an instance of %s, %s given.",
           $key,
           $class,
           $given));
     }
   }
 
   return $arr;
 }
 
 /**
  * Assert that two arrays have the exact same keys, in any order.
  *
  * @param map Array with expected keys.
  * @param map Array with actual keys.
  * @return void
  */
 function assert_same_keys(array $expect, array $actual) {
   foreach ($expect as $key => $value) {
     if (isset($actual[$key]) || array_key_exists($key, $actual)) {
       continue;
     }
 
     throw new InvalidArgumentException(
       pht(
         'Expected to find key "%s", but it is not present.',
         $key));
 
   }
 
   foreach ($actual as $key => $value) {
     if (isset($expect[$key]) || array_key_exists($key, $expect)) {
       continue;
     }
 
     throw new InvalidArgumentException(
       pht(
         'Found unexpected surplus key "%s" where no such key was expected.',
         $key));
   }
 }
 
 /**
  * Assert that passed data can be converted to string.
  *
  * @param  string    Assert that this data is valid.
  * @return void
  *
  * @task   assert
  */
 function assert_stringlike($parameter) {
   switch (gettype($parameter)) {
     case 'string':
     case 'NULL':
     case 'boolean':
     case 'double':
     case 'integer':
       return;
     case 'object':
       if (method_exists($parameter, '__toString')) {
         return;
       }
       break;
     case 'array':
     case 'resource':
     case 'unknown type':
     default:
       break;
   }
 
   throw new InvalidArgumentException(
     pht(
       'Argument must be scalar or object which implements %s!',
       '__toString()'));
 }
 
 /**
  * Returns the first argument which is not strictly null, or `null` if there
  * are no such arguments. Identical to the MySQL function of the same name.
  *
  * @param  ...         Zero or more arguments of any type.
  * @return mixed       First non-`null` arg, or null if no such arg exists.
  */
 function coalesce(/* ... */) {
   $args = func_get_args();
   foreach ($args as $arg) {
     if ($arg !== null) {
       return $arg;
     }
   }
   return null;
 }
 
 
 /**
  * Similar to @{function:coalesce}, but less strict: returns the first
  * non-`empty()` argument, instead of the first argument that is strictly
  * non-`null`. If no argument is nonempty, it returns the last argument. This
  * is useful idiomatically for setting defaults:
  *
  *   $display_name = nonempty($user_name, $full_name, "Anonymous");
  *
  * @param  ...         Zero or more arguments of any type.
  * @return mixed       First non-`empty()` arg, or last arg if no such arg
  *                     exists, or null if you passed in zero args.
  */
 function nonempty(/* ... */) {
   $args = func_get_args();
   $result = null;
   foreach ($args as $arg) {
     $result = $arg;
     if ($arg) {
       break;
     }
   }
   return $result;
 }
 
 
 /**
  * Invokes the "new" operator with a vector of arguments. There is no way to
  * `call_user_func_array()` on a class constructor, so you can instead use this
  * function:
  *
  *   $obj = newv($class_name, $argv);
  *
  * That is, these two statements are equivalent:
  *
  *   $pancake = new Pancake('Blueberry', 'Maple Syrup', true);
  *   $pancake = newv('Pancake', array('Blueberry', 'Maple Syrup', true));
  *
  * DO NOT solve this problem in other, more creative ways! Three popular
  * alternatives are:
  *
  *   - Build a fake serialized object and unserialize it.
  *   - Invoke the constructor twice.
  *   - just use `eval()` lol
  *
  * These are really bad solutions to the problem because they can have side
  * effects (e.g., __wakeup()) and give you an object in an otherwise impossible
  * state. Please endeavor to keep your objects in possible states.
  *
  * If you own the classes you're doing this for, you should consider whether
  * or not restructuring your code (for instance, by creating static
  * construction methods) might make it cleaner before using `newv()`. Static
  * constructors can be invoked with `call_user_func_array()`, and may give your
  * class a cleaner and more descriptive API.
  *
  * @param  string  The name of a class.
  * @param  list    Array of arguments to pass to its constructor.
  * @return obj     A new object of the specified class, constructed by passing
  *                 the argument vector to its constructor.
  */
 function newv($class_name, array $argv) {
   $reflector = new ReflectionClass($class_name);
   if ($argv) {
     return $reflector->newInstanceArgs($argv);
   } else {
     return $reflector->newInstance();
   }
 }
 
 
 /**
  * Returns the first element of an array. Exactly like reset(), but doesn't
  * choke if you pass it some non-referenceable value like the return value of
  * a function.
  *
  * @param    array Array to retrieve the first element from.
  * @return   wild  The first value of the array.
  */
 function head(array $arr) {
   return reset($arr);
 }
 
 /**
  * Returns the last element of an array. This is exactly like `end()` except
  * that it won't warn you if you pass some non-referencable array to
  * it -- e.g., the result of some other array operation.
  *
  * @param    array Array to retrieve the last element from.
  * @return   wild  The last value of the array.
  */
 function last(array $arr) {
   return end($arr);
 }
 
 /**
  * Returns the first key of an array.
  *
  * @param    array       Array to retrieve the first key from.
  * @return   int|string  The first key of the array.
  */
 function head_key(array $arr) {
   reset($arr);
   return key($arr);
 }
 
 /**
  * Returns the last key of an array.
  *
  * @param    array       Array to retrieve the last key from.
  * @return   int|string  The last key of the array.
  */
 function last_key(array $arr) {
   end($arr);
   return key($arr);
 }
 
 /**
  * Merge a vector of arrays performantly. This has the same semantics as
  * array_merge(), so these calls are equivalent:
  *
  *   array_merge($a, $b, $c);
  *   array_mergev(array($a, $b, $c));
  *
  * However, when you have a vector of arrays, it is vastly more performant to
  * merge them with this function than by calling array_merge() in a loop,
  * because using a loop generates an intermediary array on each iteration.
  *
  * @param list Vector of arrays to merge.
  * @return list Arrays, merged with array_merge() semantics.
  */
 function array_mergev(array $arrayv) {
   if (!$arrayv) {
     return array();
   }
 
   foreach ($arrayv as $key => $item) {
     if (!is_array($item)) {
       throw new InvalidArgumentException(
         pht(
           'Expected all items passed to `%s` to be arrays, but '.
           'argument with key "%s" has type "%s".',
           __FUNCTION__.'()',
           $key,
           gettype($item)));
     }
   }
 
   return call_user_func_array('array_merge', $arrayv);
 }
 
 
 /**
  * Split a corpus of text into lines. This function splits on "\n", "\r\n", or
  * a mixture of any of them.
  *
  * NOTE: This function does not treat "\r" on its own as a newline because none
  * of SVN, Git or Mercurial do on any OS.
  *
  * @param string Block of text to be split into lines.
  * @param bool If true, retain line endings in result strings.
  * @return list List of lines.
  *
  * @phutil-external-symbol class PhutilSafeHTML
  * @phutil-external-symbol function phutil_safe_html
  */
 function phutil_split_lines($corpus, $retain_endings = true) {
   if (!strlen($corpus)) {
     return array('');
   }
 
   // Split on "\r\n" or "\n".
   if ($retain_endings) {
     $lines = preg_split('/(?<=\n)/', $corpus);
   } else {
     $lines = preg_split('/\r?\n/', $corpus);
   }
 
   // If the text ends with "\n" or similar, we'll end up with an empty string
   // at the end; discard it.
   if (end($lines) == '') {
     array_pop($lines);
   }
 
   if ($corpus instanceof PhutilSafeHTML) {
     foreach ($lines as $key => $line) {
       $lines[$key] = phutil_safe_html($line);
     }
     return $lines;
   }
 
   return $lines;
 }
 
 
 /**
  * Simplifies a common use of `array_combine()`. Specifically, this:
  *
  *   COUNTEREXAMPLE:
  *   if ($list) {
  *     $result = array_combine($list, $list);
  *   } else {
  *     // Prior to PHP 5.4, array_combine() failed if given empty arrays.
  *     $result = array();
  *   }
  *
  * ...is equivalent to this:
  *
  *   $result = array_fuse($list);
  *
  * @param   list  List of scalars.
  * @return  dict  Dictionary with inputs mapped to themselves.
  */
 function array_fuse(array $list) {
   if ($list) {
     return array_combine($list, $list);
   }
   return array();
 }
 
 
 /**
  * Add an element between every two elements of some array. That is, given a
  * list `A, B, C, D`, and some element to interleave, `x`, this function returns
  * `A, x, B, x, C, x, D`. This works like `implode()`, but does not concatenate
  * the list into a string. In particular:
  *
  *   implode('', array_interleave($x, $list));
  *
  * ...is equivalent to:
  *
  *   implode($x, $list);
  *
  * This function does not preserve keys.
  *
  * @param wild  Element to interleave.
  * @param list  List of elements to be interleaved.
  * @return list Original list with the new element interleaved.
  */
 function array_interleave($interleave, array $array) {
   $result = array();
   foreach ($array as $item) {
     $result[] = $item;
     $result[] = $interleave;
   }
   array_pop($result);
   return $result;
 }
 
 function phutil_is_windows() {
   // We can also use PHP_OS, but that's kind of sketchy because it returns
   // "WINNT" for Windows 7 and "Darwin" for Mac OS X. Practically, testing for
   // DIRECTORY_SEPARATOR is more straightforward.
   return (DIRECTORY_SEPARATOR != '/');
 }
 
 function phutil_is_hiphop_runtime() {
   return (array_key_exists('HPHP', $_ENV) && $_ENV['HPHP'] === 1);
 }
 
 /**
  * Converts a string to a loggable one, with unprintables and newlines escaped.
  *
  * @param string  Any string.
  * @return string String with control and newline characters escaped, suitable
  *                for printing on a single log line.
  */
 function phutil_loggable_string($string) {
   if (preg_match('/^[\x20-\x7E]+$/', $string)) {
     return $string;
   }
 
   $result = '';
 
   static $c_map = array(
     '\\' => '\\\\',
     "\n" => '\\n',
     "\r" => '\\r',
     "\t" => '\\t',
   );
 
   $len = strlen($string);
   for ($ii = 0; $ii < $len; $ii++) {
     $c = $string[$ii];
     if (isset($c_map[$c])) {
       $result .= $c_map[$c];
     } else {
       $o = ord($c);
       if ($o < 0x20 || $o == 0x7F) {
         $result .= '\\x'.sprintf('%02X', $o);
       } else {
         $result .= $c;
       }
     }
   }
 
   return $result;
 }
 
 
 /**
  * Perform an `fwrite()` which distinguishes between EAGAIN and EPIPE.
  *
  * PHP's `fwrite()` is broken, and never returns `false` for writes to broken
  * nonblocking pipes: it always returns 0, and provides no straightforward
  * mechanism for distinguishing between EAGAIN (buffer is full, can't write any
  * more right now) and EPIPE or similar (no write will ever succeed).
  *
  * See: https://bugs.php.net/bug.php?id=39598
  *
  * If you call this method instead of `fwrite()`, it will attempt to detect
  * when a zero-length write is caused by EAGAIN and return `0` only if the
  * write really should be retried.
  *
  * @param resource  Socket or pipe stream.
  * @param string    Bytes to write.
  * @return bool|int Number of bytes written, or `false` on any error (including
  *                  errors which `fwrite()` can not detect, like a broken pipe).
  */
 function phutil_fwrite_nonblocking_stream($stream, $bytes) {
   if (!strlen($bytes)) {
     return 0;
   }
 
   $result = @fwrite($stream, $bytes);
   if ($result !== 0) {
     // In cases where some bytes are witten (`$result > 0`) or
     // an error occurs (`$result === false`), the behavior of fwrite() is
     // correct. We can return the value as-is.
     return $result;
   }
 
   // If we make it here, we performed a 0-length write. Try to distinguish
   // between EAGAIN and EPIPE. To do this, we're going to `stream_select()`
   // the stream, write to it again if PHP claims that it's writable, and
   // consider the pipe broken if the write fails.
 
-  // (Signals received signals during the "fwrite()" do not appear to affect
-  // anything, see D20083.)
+  // (Signals received during the "fwrite()" do not appear to affect anything,
+  // see D20083.)
 
   $read = array();
   $write = array($stream);
   $except = array();
 
   $result = @stream_select($read, $write, $except, 0);
   if ($result === false) {
     // See T13243. If the select is interrupted by a signal, it may return
     // "false" indicating an underlying EINTR condition. In this case, the
     // results (notably, "$write") are not usable because "stream_select()"
     // didn't update them.
 
     // In this case, treat this stream as blocked and tell the caller to
     // retry, since EINTR is the only condition we're currently aware of that
     // can cause "fwrite()" to return "0" and "stream_select()" to return
     // "false" on the same stream.
     return 0;
   }
 
   if (!$write) {
     // The stream isn't writable, so we conclude that it probably really is
     // blocked and the underlying error was EAGAIN. Return 0 to indicate that
     // no data could be written yet.
     return 0;
   }
 
   // If we make it here, PHP **just** claimed that this stream is writable, so
   // perform a write. If the write also fails, conclude that these failures are
   // EPIPE or some other permanent failure.
   $result = @fwrite($stream, $bytes);
   if ($result !== 0) {
     // The write worked or failed explicitly. This value is fine to return.
     return $result;
   }
 
   // We performed a 0-length write, were told that the stream was writable, and
   // then immediately performed another 0-length write. Conclude that the pipe
   // is broken and return `false`.
   return false;
 }
 
 
 /**
  * Convert a human-readable unit description into a numeric one. This function
  * allows you to replace this:
  *
  *   COUNTEREXAMPLE
  *   $ttl = (60 * 60 * 24 * 30); // 30 days
  *
  * ...with this:
  *
  *   $ttl = phutil_units('30 days in seconds');
  *
  * ...which is self-documenting and difficult to make a mistake with.
  *
  * @param   string  Human readable description of a unit quantity.
  * @return  int     Quantity of specified unit.
  */
 function phutil_units($description) {
   $matches = null;
   if (!preg_match('/^(\d+) (\w+) in (\w+)$/', $description, $matches)) {
     throw new InvalidArgumentException(
       pht(
         'Unable to parse unit specification (expected a specification in the '.
         'form "%s"): %s',
         '5 days in seconds',
         $description));
   }
 
   $quantity = (int)$matches[1];
   $src_unit = $matches[2];
   $dst_unit = $matches[3];
 
   $is_divisor = false;
 
   switch ($dst_unit) {
     case 'seconds':
       switch ($src_unit) {
         case 'second':
         case 'seconds':
           $factor = 1;
           break;
         case 'minute':
         case 'minutes':
           $factor = 60;
           break;
         case 'hour':
         case 'hours':
           $factor = 60 * 60;
           break;
         case 'day':
         case 'days':
           $factor = 60 * 60 * 24;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     case 'bytes':
       switch ($src_unit) {
         case 'byte':
         case 'bytes':
           $factor = 1;
           break;
         case 'bit':
         case 'bits':
           $factor = 8;
           $is_divisor = true;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     case 'milliseconds':
       switch ($src_unit) {
         case 'second':
         case 'seconds':
           $factor = 1000;
           break;
         case 'minute':
         case 'minutes':
           $factor = 1000 * 60;
           break;
         case 'hour':
         case 'hours':
           $factor = 1000 * 60 * 60;
           break;
         case 'day':
         case 'days':
           $factor = 1000 * 60 * 60 * 24;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     case 'microseconds':
       switch ($src_unit) {
         case 'second':
         case 'seconds':
           $factor = 1000000;
           break;
         case 'minute':
         case 'minutes':
           $factor = 1000000 * 60;
           break;
         case 'hour':
         case 'hours':
           $factor = 1000000 * 60 * 60;
           break;
         case 'day':
         case 'days':
           $factor = 1000000 * 60 * 60 * 24;
           break;
         default:
           throw new InvalidArgumentException(
             pht(
               'This function can not convert from the unit "%s".',
               $src_unit));
       }
       break;
 
     default:
       throw new InvalidArgumentException(
         pht(
           'This function can not convert into the unit "%s".',
           $dst_unit));
   }
 
   if ($is_divisor) {
     if ($quantity % $factor) {
       throw new InvalidArgumentException(
         pht(
           '"%s" is not an exact quantity.',
           $description));
     }
     return (int)($quantity / $factor);
   } else {
     return $quantity * $factor;
   }
 }
 
 
 /**
  * Compute the number of microseconds that have elapsed since an earlier
  * timestamp (from `microtime(true)`).
  *
  * @param double Microsecond-precision timestamp, from `microtime(true)`.
  * @return int Elapsed microseconds.
  */
 function phutil_microseconds_since($timestamp) {
   if (!is_float($timestamp)) {
     throw new Exception(
       pht(
         'Argument to "phutil_microseconds_since(...)" should be a value '.
         'returned from "microtime(true)".'));
   }
 
   $delta = (microtime(true) - $timestamp);
   $delta = 1000000 * $delta;
   $delta = (int)$delta;
 
   return $delta;
 }
 
 
 /**
  * Decode a JSON dictionary.
  *
  * @param   string    A string which ostensibly contains a JSON-encoded list or
  *                    dictionary.
  * @return  mixed     Decoded list/dictionary.
  */
 function phutil_json_decode($string) {
   $result = @json_decode($string, true);
 
   if (!is_array($result)) {
     // Failed to decode the JSON. Try to use @{class:PhutilJSONParser} instead.
     // This will probably fail, but will throw a useful exception.
     $parser = new PhutilJSONParser();
     $result = $parser->parse($string);
   }
 
   return $result;
 }
 
 
 /**
  * Encode a value in JSON, raising an exception if it can not be encoded.
  *
  * @param wild A value to encode.
  * @return string JSON representation of the value.
  */
 function phutil_json_encode($value) {
   $result = @json_encode($value);
   if ($result === false) {
     $reason = phutil_validate_json($value);
     if (function_exists('json_last_error')) {
       $err = json_last_error();
       if (function_exists('json_last_error_msg')) {
         $msg = json_last_error_msg();
         $extra = pht('#%d: %s', $err, $msg);
       } else {
         $extra = pht('#%d', $err);
       }
     } else {
       $extra = null;
     }
 
     if ($extra) {
       $message = pht(
         'Failed to JSON encode value (%s): %s.',
         $extra,
         $reason);
     } else {
       $message = pht(
         'Failed to JSON encode value: %s.',
         $reason);
     }
 
     throw new Exception($message);
   }
 
   return $result;
 }
 
 
 /**
  * Produce a human-readable explanation why a value can not be JSON-encoded.
  *
  * @param wild Value to validate.
  * @param string Path within the object to provide context.
  * @return string|null Explanation of why it can't be encoded, or null.
  */
 function phutil_validate_json($value, $path = '') {
   if ($value === null) {
     return;
   }
 
   if ($value === true) {
     return;
   }
 
   if ($value === false) {
     return;
   }
 
   if (is_int($value)) {
     return;
   }
 
   if (is_float($value)) {
     return;
   }
 
   if (is_array($value)) {
     foreach ($value as $key => $subvalue) {
       if (strlen($path)) {
         $full_key = $path.' > ';
       } else {
         $full_key = '';
       }
 
       if (!phutil_is_utf8($key)) {
         $full_key = $full_key.phutil_utf8ize($key);
         return pht(
           'Dictionary key "%s" is not valid UTF8, and cannot be JSON encoded.',
           $full_key);
       }
 
       $full_key .= $key;
       $result = phutil_validate_json($subvalue, $full_key);
       if ($result !== null) {
         return $result;
       }
     }
   }
 
   if (is_string($value)) {
     if (!phutil_is_utf8($value)) {
       $display = substr($value, 0, 256);
       $display = phutil_utf8ize($display);
       if (!strlen($path)) {
         return pht(
           'String value is not valid UTF8, and can not be JSON encoded: %s',
           $display);
       } else {
         return pht(
           'Dictionary value at key "%s" is not valid UTF8, and cannot be '.
           'JSON encoded: %s',
           $path,
           $display);
       }
     }
   }
 
   return;
 }
 
 
 /**
  * Decode an INI string.
  *
  * @param  string
  * @return mixed
  */
 function phutil_ini_decode($string) {
   $results = null;
   $trap = new PhutilErrorTrap();
 
   try {
     $have_call = false;
     if (function_exists('parse_ini_string')) {
       if (defined('INI_SCANNER_RAW')) {
         $results = @parse_ini_string($string, true, INI_SCANNER_RAW);
         $have_call = true;
       }
     }
 
     if (!$have_call) {
       throw new PhutilMethodNotImplementedException(
         pht(
           '%s is not compatible with your version of PHP (%s). This function '.
           'is only supported on PHP versions newer than 5.3.0.',
           __FUNCTION__,
           phpversion()));
     }
 
     if ($results === false) {
       throw new PhutilINIParserException(trim($trap->getErrorsAsString()));
     }
 
     foreach ($results as $section => $result) {
       if (!is_array($result)) {
         // We JSON decode the value in ordering to perform the following
         // conversions:
         //
         //   - `'true'` => `true`
         //   - `'false'` => `false`
         //   - `'123'` => `123`
         //   - `'1.234'` => `1.234`
         //
         $result = json_decode($result, true);
 
         if ($result !== null && !is_array($result)) {
           $results[$section] = $result;
         }
 
         continue;
       }
 
       foreach ($result as $key => $value) {
         $value = json_decode($value, true);
 
         if ($value !== null && !is_array($value)) {
           $results[$section][$key] = $value;
         }
       }
     }
   } catch (Exception $ex) {
     $trap->destroy();
     throw $ex;
   }
 
   $trap->destroy();
   return $results;
 }
 
 
 /**
  * Attempt to censor any plaintext credentials from a string.
  *
  * The major use case here is to censor usernames and passwords from command
  * output. For example, when `git fetch` fails, the output includes credentials
  * for authenticated HTTP remotes.
  *
  * @param   string  Some block of text.
  * @return  string  A similar block of text, but with credentials that could
  *                  be identified censored.
  */
 function phutil_censor_credentials($string) {
   return preg_replace(',(?<=://)([^/@\s]+)(?=@|$),', '********', $string);
 }
 
 
 /**
  * Returns a parsable string representation of a variable.
  *
  * This function is intended to behave similarly to PHP's `var_export` function,
  * but the output is intended to follow our style conventions.
  *
  * @param  wild    The variable you want to export.
  * @return string
  */
 function phutil_var_export($var) {
   // `var_export(null, true)` returns `"NULL"` (in uppercase).
   if ($var === null) {
     return 'null';
   }
 
   // PHP's `var_export` doesn't format arrays very nicely. In particular:
   //
   //   - An empty array is split over two lines (`"array (\n)"`).
   //   - A space separates "array" and the first opening brace.
   //   - Non-associative arrays are returned as associative arrays with an
   //     integer key.
   //
   if (is_array($var)) {
     if (count($var) === 0) {
       return 'array()';
     }
 
     // Don't show keys for non-associative arrays.
     $show_keys = !phutil_is_natural_list($var);
 
     $output = array();
     $output[] = 'array(';
 
     foreach ($var as $key => $value) {
       // Adjust the indentation of the value.
       $value = str_replace("\n", "\n  ", phutil_var_export($value));
       $output[] = '  '.
         ($show_keys ? var_export($key, true).' => ' : '').
         $value.',';
     }
 
     $output[] = ')';
     return implode("\n", $output);
   }
 
   // Let PHP handle everything else.
   return var_export($var, true);
 }
 
 
 /**
  * An improved version of `fnmatch`.
  *
  * @param  string  A glob pattern.
  * @param  string  A path.
  * @return bool
  */
 function phutil_fnmatch($glob, $path) {
   // Modify the glob to allow `**/` to match files in the root directory.
   $glob = preg_replace('@(?:(?<!\\\\)\\*){2}/@', '{,*/,**/}', $glob);
 
   $escaping = false;
   $in_curlies = 0;
   $regex = '';
 
   for ($i = 0; $i < strlen($glob); $i++) {
     $char = $glob[$i];
     $next_char = ($i < strlen($glob) - 1) ? $glob[$i + 1] : null;
 
     $escape = array('$', '(', ')', '+', '.', '^', '|');
     $mapping = array();
 
     if ($escaping) {
       $escape[] = '*';
       $escape[] = '?';
       $escape[] = '{';
     } else {
       $mapping['*'] = $next_char === '*' ? '.*' : '[^/]*';
       $mapping['?'] = '[^/]';
       $mapping['{'] = '(';
 
       if ($in_curlies) {
         $mapping[','] = '|';
         $mapping['}'] = ')';
       }
     }
 
     if (in_array($char, $escape)) {
       $regex .= "\\{$char}";
     } else if ($replacement = idx($mapping, $char)) {
       $regex .= $replacement;
     } else if ($char === '\\') {
       if ($escaping) {
         $regex .= '\\\\';
       }
       $escaping = !$escaping;
       continue;
     } else {
       $regex .= $char;
     }
 
     if ($char === '{' && !$escaping) {
       $in_curlies++;
     } else if ($char === '}' && $in_curlies && !$escaping) {
       $in_curlies--;
     }
 
     $escaping = false;
   }
 
   if ($in_curlies || $escaping) {
     throw new InvalidArgumentException(pht('Invalid glob pattern.'));
   }
 
   $regex = '(\A'.$regex.'\z)';
   return (bool)preg_match($regex, $path);
 }
 
 
 /**
  * Compare two hashes for equality.
  *
  * This function defuses two attacks: timing attacks and type juggling attacks.
  *
  * In a timing attack, the attacker observes that strings which match the
  * secret take slightly longer to fail to match because more characters are
  * compared. By testing a large number of strings, they can learn the secret
  * character by character. This defuses timing attacks by always doing the
  * same amount of work.
  *
  * In a type juggling attack, an attacker takes advantage of PHP's type rules
  * where `"0" == "0e12345"` for any exponent. A portion of of hexadecimal
  * hashes match this pattern and are vulnerable. This defuses this attack by
  * performing bytewise character-by-character comparison.
  *
  * It is questionable how practical these attacks are, but they are possible
  * in theory and defusing them is straightforward.
  *
  * @param string First hash.
  * @param string Second hash.
  * @return bool True if hashes are identical.
  */
 function phutil_hashes_are_identical($u, $v) {
   if (!is_string($u)) {
     throw new Exception(pht('First hash argument must be a string.'));
   }
 
   if (!is_string($v)) {
     throw new Exception(pht('Second hash argument must be a string.'));
   }
 
   if (strlen($u) !== strlen($v)) {
     return false;
   }
 
   $len = strlen($v);
 
   $bits = 0;
   for ($ii = 0; $ii < $len; $ii++) {
     $bits |= (ord($u[$ii]) ^ ord($v[$ii]));
   }
 
   return ($bits === 0);
 }
 
 
 /**
  * Build a query string from a dictionary.
  *
  * @param map<string, string> Dictionary of parameters.
  * @return string HTTP query string.
  */
 function phutil_build_http_querystring(array $parameters) {
   $pairs = array();
   foreach ($parameters as $key => $value) {
     $pairs[] = array($key, $value);
   }
 
   return phutil_build_http_querystring_from_pairs($pairs);
 }
 
 /**
  * Build a query string from a list of parameter pairs.
  *
  * @param list<pair<string, string>> List of pairs.
  * @return string HTTP query string.
  */
 function phutil_build_http_querystring_from_pairs(array $pairs) {
   // We want to encode in RFC3986 mode, but "http_build_query()" did not get
   // a flag for that mode until PHP 5.4.0. This is equivalent to calling
   // "http_build_query()" with the "PHP_QUERY_RFC3986" flag.
 
   $query = array();
   foreach ($pairs as $pair_key => $pair) {
     if (!is_array($pair) || (count($pair) !== 2)) {
       throw new Exception(
         pht(
           'HTTP parameter pair (with key "%s") is not valid: each pair must '.
           'be an array with exactly two elements.',
           $pair_key));
     }
 
     list($key, $value) = $pair;
     list($key, $value) = phutil_http_parameter_pair($key, $value);
     $query[] = rawurlencode($key).'='.rawurlencode($value);
   }
   $query = implode('&', $query);
 
   return $query;
 }
 
 /**
  * Typecheck and cast an HTTP key-value parameter pair.
  *
  * Scalar values are converted to strings. Nonscalar values raise exceptions.
  *
  * @param scalar HTTP parameter key.
  * @param scalar HTTP parameter value.
  * @return pair<string, string> Key and value as strings.
  */
 function phutil_http_parameter_pair($key, $value) {
   try {
     assert_stringlike($key);
   } catch (InvalidArgumentException $ex) {
     throw new PhutilProxyException(
       pht('HTTP query parameter key must be a scalar.'),
       $ex);
   }
 
   $key = phutil_string_cast($key);
 
   try {
     assert_stringlike($value);
   } catch (InvalidArgumentException $ex) {
     throw new PhutilProxyException(
       pht(
         'HTTP query parameter value (for key "%s") must be a scalar.',
         $key),
       $ex);
   }
 
   $value = phutil_string_cast($value);
 
   return array($key, $value);
 }
 
 function phutil_decode_mime_header($header) {
   if (function_exists('iconv_mime_decode')) {
     return iconv_mime_decode($header, 0, 'UTF-8');
   }
 
   if (function_exists('mb_decode_mimeheader')) {
     return mb_decode_mimeheader($header);
   }
 
   throw new Exception(
     pht(
       'Unable to decode MIME header: install "iconv" or "mbstring" '.
       'extension.'));
 }
 
 /**
  * Perform a "(string)" cast without disabling standard exception behavior.
  *
  * When PHP invokes "__toString()" automatically, it fatals if the method
  * raises an exception. In older versions of PHP (until PHP 7.1), this fatal is
  * fairly opaque and does not give you any information about the exception
  * itself, although newer versions of PHP at least include the exception
  * message.
  *
  * This is documented on the "__toString()" manual page:
  *
  *   Warning
  *   You cannot throw an exception from within a __toString() method. Doing
  *   so will result in a fatal error.
  *
  * However, this only applies to implicit invocation by the language runtime.
  * Application code can safely call `__toString()` directly without any effect
  * on exception handling behavior. Very cool.
  *
  * We also reject arrays. PHP casts them to the string "Array". This behavior
  * is, charitably, evil.
  *
  * @param wild Any value which aspires to be represented as a string.
  * @return string String representation of the provided value.
  */
 function phutil_string_cast($value) {
   if (is_array($value)) {
     throw new Exception(
       pht(
         'Value passed to "phutil_string_cast()" is an array; arrays can '.
         'not be sensibly cast to strings.'));
   }
 
   if (is_object($value)) {
     $string = $value->__toString();
 
     if (!is_string($string)) {
       throw new Exception(
         pht(
           'Object (of class "%s") did not return a string from "__toString()".',
           get_class($value)));
     }
 
     return $string;
   }
 
   return (string)$value;
 }
 
 
 /**
  * Return a short, human-readable description of an object's type.
  *
  * This is mostly useful for raising errors like "expected x() to return a Y,
  * but it returned a Z".
  *
  * This is similar to "get_type()", but describes objects and arrays in more
  * detail.
  *
  * @param wild Anything.
  * @return string Human-readable description of the value's type.
  */
 function phutil_describe_type($value) {
   return PhutilTypeSpec::getTypeOf($value);
 }
 
 
 /**
  * Test if a list has the natural numbers (1, 2, 3, and so on) as keys, in
  * order.
  *
  * @return bool True if the list is a natural list.
  */
 function phutil_is_natural_list(array $list) {
   $expect = 0;
 
   foreach ($list as $key => $item) {
     if ($key !== $expect) {
       return false;
     }
     $expect++;
   }
 
   return true;
 }
 
 
 /**
  * Escape text for inclusion in a URI or a query parameter. Note that this
  * method does NOT escape '/', because "%2F" is invalid in paths and Apache
  * will automatically 404 the page if it's present. This will produce correct
  * (the URIs will work) and desirable (the URIs will be readable) behavior in
  * these cases:
  *
  *    '/path/?param='.phutil_escape_uri($string);         # OK: Query Parameter
  *    '/path/to/'.phutil_escape_uri($string);             # OK: URI Suffix
  *
  * It will potentially produce the WRONG behavior in this special case:
  *
  *    COUNTEREXAMPLE
  *    '/path/to/'.phutil_escape_uri($string).'/thing/';   # BAD: URI Infix
  *
  * In this case, any '/' characters in the string will not be escaped, so you
  * will not be able to distinguish between the string and the suffix (unless
  * you have more information, like you know the format of the suffix). For infix
  * URI components, use @{function:phutil_escape_uri_path_component} instead.
  *
  * @param   string  Some string.
  * @return  string  URI encoded string, except for '/'.
  */
 function phutil_escape_uri($string) {
   return str_replace('%2F', '/', rawurlencode($string));
 }
 
 
 /**
  * Escape text for inclusion as an infix URI substring. See discussion at
  * @{function:phutil_escape_uri}. This function covers an unusual special case;
  * @{function:phutil_escape_uri} is usually the correct function to use.
  *
  * This function will escape a string into a format which is safe to put into
  * a URI path and which does not contain '/' so it can be correctly parsed when
  * embedded as a URI infix component.
  *
  * However, you MUST decode the string with
  * @{function:phutil_unescape_uri_path_component} before it can be used in the
  * application.
  *
  * @param   string  Some string.
  * @return  string  URI encoded string that is safe for infix composition.
  */
 function phutil_escape_uri_path_component($string) {
   return rawurlencode(rawurlencode($string));
 }
 
 
 /**
  * Unescape text that was escaped by
  * @{function:phutil_escape_uri_path_component}. See
  * @{function:phutil_escape_uri} for discussion.
  *
  * Note that this function is NOT the inverse of
  * @{function:phutil_escape_uri_path_component}! It undoes additional escaping
  * which is added to survive the implied unescaping performed by the webserver
  * when interpreting the request.
  *
  * @param string  Some string emitted
  *                from @{function:phutil_escape_uri_path_component} and
  *                then accessed via a web server.
  * @return string Original string.
  */
 function phutil_unescape_uri_path_component($string) {
   return rawurldecode($string);
 }
diff --git a/src/xsprintf/PhutilTerminalString.php b/src/xsprintf/PhutilTerminalString.php
index 8d99b093..1d42f288 100644
--- a/src/xsprintf/PhutilTerminalString.php
+++ b/src/xsprintf/PhutilTerminalString.php
@@ -1,75 +1,82 @@
 <?php
 
 /**
  * String escaped for terminal output. See @{function:tsprintf}.
  */
 final class PhutilTerminalString extends Phobject {
 
   private $string;
 
   public function __construct($string) {
     $this->string = $string;
   }
 
   public function __toString() {
     return $this->string;
   }
 
   public function applyWrap() {
     $string = (string)$this;
     $string = phutil_console_wrap($string);
     return new self($string);
   }
 
   public function applyIndent($depth, $with_prefix = true) {
     $string = (string)$this;
     $string = phutil_console_wrap($string, $depth, $with_prefix);
     return new self($string);
   }
 
   public static function escapeStringValue($value, $allow_whitespace) {
     if ($value instanceof PhutilTerminalString) {
       return (string)$value;
     }
 
     $value = (string)$value;
 
     static $escape_map;
     if ($escape_map === null) {
       $escape_map = array(
         chr(0x00) => '<NUL>',
         chr(0x07) => '<BEL>',
         chr(0x08) => '<BS>',
         chr(0x09) => '<TAB>',
         chr(0x0A) => '<LF>',
         chr(0x0D) => '<CR>',
         chr(0x1B) => '<ESC>',
         chr(0x7F) => '<DEL>',
       );
 
       for ($ii = 0; $ii < 32; $ii++) {
         $c = chr($ii);
         if (empty($escape_map[$c])) {
           $escape_map[$c] = sprintf('<0x%02X>', $ii);
         }
       }
     }
 
     $map = $escape_map;
     if ($allow_whitespace) {
       unset($map["\r"]);
       unset($map["\n"]);
       unset($map["\t"]);
     }
 
     $value = str_replace(array_keys($map), array_values($map), $value);
 
     // In this mode, we additionally escape any <CR> which is not immediately
     // followed by <LF>.
     if ($allow_whitespace) {
       $value = preg_replace('/\r(?!\n)/', '<CR>', $value);
     }
 
+    // See T13209. If we print certain invalid unicode byte sequences to the
+    // terminal under "cmd.exe", the entire string is silently dropped. Avoid
+    // printing invalid sequences.
+    if (phutil_is_windows()) {
+      $value = phutil_utf8ize($value);
+    }
+
     return $value;
   }
 }
diff --git a/src/xsprintf/__tests__/PhutilCsprintfTestCase.php b/src/xsprintf/__tests__/PhutilCsprintfTestCase.php
index 05a26c72..b7cbc18b 100644
--- a/src/xsprintf/__tests__/PhutilCsprintfTestCase.php
+++ b/src/xsprintf/__tests__/PhutilCsprintfTestCase.php
@@ -1,96 +1,107 @@
 <?php
 
 final class PhutilCsprintfTestCase extends PhutilTestCase {
 
   public function testCommandReadableEscapes() {
     $inputs = array(
       // For arguments comprised of only characters which are safe in any
       // context, %R this should avoid adding quotes.
       'ab' => true,
 
       // For arguments which have any characters which are not safe in some
       // context, %R should apply standard escaping.
       'a b' => false,
 
 
       'http://domain.com/path/' => true,
       'svn+ssh://domain.com/path/' => true,
       '`rm -rf`' => false,
       '$VALUE' => false,
     );
 
     foreach ($inputs as $input => $expect_same) {
       $actual = (string)csprintf('%R', $input);
       if ($expect_same) {
         $this->assertEqual($input, $actual);
       } else {
         $this->assertFalse($input === $actual);
       }
     }
   }
 
   public function testPowershell() {
     $cmd = csprintf('%s', "\n");
     $cmd->setEscapingMode(PhutilCommandString::MODE_POWERSHELL);
 
     $this->assertEqual(
       '"`n"',
       (string)$cmd);
   }
 
   public function testNoPowershell() {
-    if (!phutil_is_windows()) {
-      $cmd = csprintf('%s', '#');
-      $cmd->setEscapingMode(PhutilCommandString::MODE_DEFAULT);
-
-      $this->assertEqual(
-        '\'#\'',
-        (string)$cmd);
+    if (phutil_is_windows()) {
+      // TOOLSETS: Restructure this. We must skip because tests fail if they
+      // do not make any assertions.
+      $this->assertSkipped(
+        pht(
+          'This test can not currently run under Windows.'));
     }
+
+    $cmd = csprintf('%s', '#');
+    $cmd->setEscapingMode(PhutilCommandString::MODE_DEFAULT);
+
+    $this->assertEqual(
+      '\'#\'',
+      (string)$cmd);
   }
 
   public function testPasswords() {
+    $bin = $this->getSupportExecutable('echo');
+
     // Normal "%s" doesn't do anything special.
-    $command = csprintf('echo %s', 'hunter2trustno1');
+    $command = csprintf('php -f %R -- %s', $bin, 'hunter2trustno1');
     $this->assertTrue(strpos($command, 'hunter2trustno1') !== false);
 
     // "%P" takes a PhutilOpaqueEnvelope.
     $caught = null;
     try {
-      csprintf('echo %P', 'hunter2trustno1');
+      csprintf('php -f %R -- %P', $bin, 'hunter2trustno1');
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue($caught instanceof InvalidArgumentException);
 
 
     // "%P" masks the provided value.
-    $command = csprintf('echo %P', new PhutilOpaqueEnvelope('hunter2trustno1'));
+    $command = csprintf(
+      'php -f %R -- %P',
+      $bin,
+      new PhutilOpaqueEnvelope('hunter2trustno1'));
     $this->assertFalse(strpos($command, 'hunter2trustno1'));
 
 
     // Executing the command works as expected.
     list($out) = execx('%C', $command);
     $this->assertTrue(strpos($out, 'hunter2trustno1') !== false);
   }
 
   public function testEscapingIsRobust() {
     if (phutil_is_windows()) {
       $this->assertSkipped(pht("This test doesn't work on Windows."));
     }
 
     // Escaping should be robust even when used to escape commands which take
     // other commands.
     list($out) = execx(
       'sh -c %s',
       csprintf(
         'sh -c %s',
         csprintf(
           'sh -c %s',
           csprintf(
             'echo %P',
             new PhutilOpaqueEnvelope('!@#$%^&*()')))));
     $this->assertTrue(strpos($out, '!@#$%^&*()') !== false);
   }
 
 }
diff --git a/scripts/init/init-script.php b/support/init/init-script.php
similarity index 93%
rename from scripts/init/init-script.php
rename to support/init/init-script.php
index 3609a178..77ed7d03 100644
--- a/scripts/init/init-script.php
+++ b/support/init/init-script.php
@@ -1,100 +1,101 @@
 <?php
 
-if (function_exists('pcntl_async_signals')) {
-  pcntl_async_signals(true);
-} else {
-  declare(ticks = 1);
-}
-
-function __phutil_init_script__() {
+function __arcanist_init_script__() {
   // Adjust the runtime language configuration to be reasonable and inline with
   // expectations. We do this first, then load libraries.
 
   // There may be some kind of auto-prepend script configured which starts an
   // output buffer. Discard any such output buffers so messages can be sent to
   // stdout (if a user wants to capture output from a script, there are a large
   // number of ways they can accomplish it legitimately; historically, we ran
   // into this on only one install which had some bizarre configuration, but it
   // was difficult to diagnose because the symptom is "no messages of any
   // kind").
   while (ob_get_level() > 0) {
     ob_end_clean();
   }
 
   error_reporting(E_ALL | E_STRICT);
 
   $config_map = array(
     // Always display script errors. Without this, they may not appear, which is
     // unhelpful when users encounter a problem. On the web this is a security
     // concern because you don't want to expose errors to clients, but in a
     // script context we always want to show errors.
     'display_errors'              => true,
 
     // Send script error messages to the server's `error_log` setting.
     'log_errors'                  => true,
 
     // Set the error log to the default, so errors go to stderr. Without this
     // errors may end up in some log, and users may not know where the log is
     // or check it.
     'error_log'                   => null,
 
     // XDebug raises a fatal error if the call stack gets too deep, but the
     // default setting is 100, which we may exceed legitimately with module
     // includes (and in other cases, like recursive filesystem operations
     // applied to 100+ levels of directory nesting). Stop it from triggering:
     // we explicitly limit recursive algorithms which should be limited.
     //
     // After Feb 2014, XDebug interprets a value of 0 to mean "do not allow any
     // function calls". Previously, 0 effectively disabled this check. For
     // context, see T5027.
     'xdebug.max_nesting_level'    => PHP_INT_MAX,
 
     // Don't limit memory, doing so just generally just prevents us from
     // processing large inputs without many tangible benefits.
     'memory_limit'                => -1,
 
     // See T13296. On macOS under PHP 7.3.x, PCRE currently segfaults after
     // "fork()" if "pcre.jit" is enabled.
     'pcre.jit' => 0,
   );
 
   foreach ($config_map as $config_key => $config_value) {
     ini_set($config_key, $config_value);
   }
 
   if (!ini_get('date.timezone')) {
     // If the timezone isn't set, PHP issues a warning whenever you try to parse
     // a date (like those from Git or Mercurial logs), even if the date contains
     // timezone information (like "PST" or "-0700") which makes the
     // environmental timezone setting is completely irrelevant. We never rely on
     // the system timezone setting in any capacity, so prevent PHP from flipping
     // out by setting it to a safe default (UTC) if it isn't set to some other
     // value.
     date_default_timezone_set('UTC');
   }
 
   // Adjust `include_path`.
   ini_set('include_path', implode(PATH_SEPARATOR, array(
     dirname(dirname(__FILE__)).'/externals/includes',
     ini_get('include_path'),
   )));
 
   // Disable the insanely dangerous XML entity loader by default.
   if (function_exists('libxml_disable_entity_loader')) {
     libxml_disable_entity_loader(true);
   }
 
   $root = dirname(dirname(dirname(__FILE__)));
   require_once $root.'/src/init/init-library.php';
 
   PhutilErrorHandler::initialize();
+
+  PhutilErrorHandler::initialize();
+
+  // If "variables_order" excludes "E", silently repair it so that $_ENV has
+  // the values we expect.
+  PhutilExecutionEnvironment::repairMissingVariablesOrder();
+
   $router = PhutilSignalRouter::initialize();
 
   $handler = new PhutilBacktraceSignalHandler();
   $router->installHandler('phutil.backtrace', $handler);
 
   $handler = new PhutilConsoleMetricsSignalHandler();
   $router->installHandler('phutil.winch', $handler);
 }
 
-__phutil_init_script__();
+__arcanist_init_script__();
diff --git a/support/lib/extract-symbols.php b/support/lib/extract-symbols.php
index 370d5ba8..7b9378b1 100755
--- a/support/lib/extract-symbols.php
+++ b/support/lib/extract-symbols.php
@@ -1,587 +1,587 @@
 #!/usr/bin/env php
 <?php
 
 // We have to do this first before we load any symbols, because we define the
 // built-in symbol list through introspection.
 $builtins = phutil_symbols_get_builtins();
 
 $root = dirname(dirname(dirname(__FILE__)));
-require_once $root.'/scripts/init/init-script.php';
+require_once $root.'/support/init/init-script.php';
 
 $args = new PhutilArgumentParser($argv);
 $args->setTagline(pht('identify symbols in a PHP source file'));
 $args->setSynopsis(<<<EOHELP
     **extract-symbols.php** [__options__] __path.php__
         Identify the symbols (clases, functions and interfaces) in a PHP
         source file. Symbols are divided into "have" symbols (symbols the file
         declares) and "need" symbols (symbols the file depends on). For example,
         class declarations are "have" symbols, while object instantiations
         with "new X()" are "need" symbols.
 
         Dependencies on builtins and symbols marked '@phutil-external-symbol'
         in docblocks are omitted without __--all__.
 
         Symbols are reported in JSON on stdout.
 
         This script is used internally by libphutil/arcanist to build maps of
         library symbols.
 
         It would be nice to eventually implement this as a C++ xhpast binary,
         as it's relatively stable and performance is currently awful
         (500ms+ for moderately large files).
 
 EOHELP
 );
 $args->parseStandardArguments();
 $args->parse(
   array(
     array(
       'name'      => 'all',
       'help'      => pht(
         'Report all symbols, including built-ins and declared externals.'),
     ),
     array(
       'name'      => 'ugly',
       'help'      => pht('Do not prettify JSON output.'),
     ),
     array(
       'name'      => 'path',
       'wildcard'  => true,
       'help'      => pht('PHP Source file to analyze.'),
     ),
   ));
 
 $paths = $args->getArg('path');
 if (count($paths) !== 1) {
   throw new Exception(pht('Specify exactly one path!'));
 }
 $path = Filesystem::resolvePath(head($paths));
 
 $show_all = $args->getArg('all');
 
 $source_code = Filesystem::readFile($path);
 
 try {
   $tree = XHPASTTree::newFromData($source_code);
 } catch (XHPASTSyntaxErrorException $ex) {
   $result = array(
     'error' => $ex->getMessage(),
     'line'  => $ex->getErrorLine(),
     'file'  => $path,
   );
   $json = new PhutilJSON();
   echo $json->encodeFormatted($result);
   exit(0);
 }
 
 $root = $tree->getRootNode();
 $root->buildSelectCache();
 
 // -(  Unsupported Constructs  )------------------------------------------------
 
 $namespaces = $root->selectDescendantsOfType('n_NAMESPACE');
 foreach ($namespaces as $namespace) {
   phutil_fail_on_unsupported_feature($namespace, $path, pht('namespaces'));
 }
 
 $uses = $root->selectDescendantsOfType('n_USE');
 foreach ($namespaces as $namespace) {
   phutil_fail_on_unsupported_feature(
     $namespace, $path, pht('namespace `%s` statements', 'use'));
 }
 
 $possible_traits = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
 foreach ($possible_traits as $possible_trait) {
   $attributes = $possible_trait->getChildByIndex(0);
   // Can't use getChildByIndex here because not all classes have attributes
   foreach ($attributes->getChildren() as $attribute) {
     if (strtolower($attribute->getConcreteString()) === 'trait') {
       phutil_fail_on_unsupported_feature($possible_trait, $path, pht('traits'));
     }
   }
 }
 
 
 // -(  Marked Externals  )------------------------------------------------------
 
 
 // Identify symbols marked with "@phutil-external-symbol", so we exclude them
 // from the dependency list.
 
 $externals = array();
 $doc_parser = new PhutilDocblockParser();
 foreach ($root->getTokens() as $token) {
   if ($token->getTypeName() === 'T_DOC_COMMENT') {
     list($block, $special) = $doc_parser->parse($token->getValue());
 
     $ext_list = idx($special, 'phutil-external-symbol');
     $ext_list = (array)$ext_list;
     $ext_list = array_filter($ext_list);
 
     foreach ($ext_list as $ext_ref) {
       $matches = null;
       if (preg_match('/^\s*(\S+)\s+(\S+)/', $ext_ref, $matches)) {
         $externals[$matches[1]][$matches[2]] = true;
       }
     }
   }
 }
 
 
 // -(  Declarations and Dependencies  )-----------------------------------------
 
 
 // The first stage of analysis is to find all the symbols we declare in the
 // file (like functions and classes) and all the symbols we use in the file
 // (like calling functions and invoking classes). Later, we filter this list
 // to exclude builtins.
 
 
 $have = array();  // For symbols we declare.
 $need = array();  // For symbols we use.
 $xmap = array();  // For extended classes and implemented interfaces.
 
 
 // -(  Functions  )-------------------------------------------------------------
 
 
 // Find functions declared in this file.
 
 // This is "function f() { ... }".
 $functions = $root->selectDescendantsOfType('n_FUNCTION_DECLARATION');
 foreach ($functions as $function) {
   $name = $function->getChildByIndex(2);
   if ($name->getTypeName() === 'n_EMPTY') {
     // This is an anonymous function; don't record it into the symbol
     // index.
     continue;
   }
   $have[] = array(
     'type'    => 'function',
     'symbol'  => $name,
   );
 }
 
 
 // Find functions used by this file. Uses:
 //
 //  - Explicit Call
 //  - String literal passed to call_user_func() or call_user_func_array()
 //  - String literal in array literal in call_user_func()/call_user_func_array()
 //
 // TODO: Possibly support these:
 //
 //  - String literal in ReflectionFunction().
 
 // This is "f();".
 $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
 foreach ($calls as $call) {
   $name = $call->getChildByIndex(0);
   if ($name->getTypeName() === 'n_VARIABLE' ||
       $name->getTypeName() === 'n_VARIABLE_VARIABLE') {
     // Ignore these, we can't analyze them.
     continue;
   }
   if ($name->getTypeName() === 'n_CLASS_STATIC_ACCESS') {
     // These are "C::f()", we'll pick this up later on.
     continue;
   }
   $call_name = $name->getConcreteString();
   if ($call_name === 'call_user_func' ||
       $call_name === 'call_user_func_array') {
     $params = $call->getChildByIndex(1)->getChildren();
     if (!count($params)) {
       // This is a bare call_user_func() with no arguments; just ignore it.
       continue;
     }
     $symbol = array_shift($params);
     $type = 'function';
     $symbol_value = $symbol->getStringLiteralValue();
     $pos = strpos($symbol_value, '::');
     if ($pos) {
       $type = 'class';
       $symbol_value = substr($symbol_value, 0, $pos);
     } else if ($symbol->getTypeName() === 'n_ARRAY_LITERAL') {
       try {
         $type = 'class';
         $symbol_value = idx($symbol->evalStatic(), 0);
       } catch (Exception $ex) {}
     }
     if ($symbol_value && strpos($symbol_value, '$') === false) {
       $need[] = array(
         'type'    => $type,
         'name'    => $symbol_value,
         'symbol'  => $symbol,
       );
     }
   } else {
     $need[] = array(
       'type'    => 'function',
       'symbol'  => $name,
     );
   }
 }
 
 
 // -(  Classes  )---------------------------------------------------------------
 
 
 // Find classes declared by this file.
 
 
 // This is "class X ... { ... }".
 $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
 foreach ($classes as $class) {
   $class_name = $class->getChildByIndex(1);
   $have[] = array(
     'type'    => 'class',
     'symbol'  => $class_name,
   );
 }
 
 
 // Find classes used by this file. We identify these:
 //
 //  - class ... extends X
 //  - new X
 //  - Static method call
 //  - Static property access
 //  - Use of class constant
 //  - typehints
 //  - catch
 //  - instanceof
 //  - newv()
 //
 // TODO: Possibly support these:
 //
 //  - String literal in ReflectionClass().
 
 
 // This is "class X ... { ... }".
 $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
 foreach ($classes as $class) {
   $class_name = $class->getChildByIndex(1)->getConcreteString();
   $extends = $class->getChildByIndex(2);
   foreach ($extends->selectDescendantsOfType('n_CLASS_NAME') as $parent) {
     $need[] = array(
       'type'    => 'class',
       'symbol'  => $parent,
     );
 
     // Track all 'extends' in the extension map.
     $xmap[$class_name][] = $parent->getConcreteString();
   }
 }
 
 // This is "new X()".
 $uses_of_new = $root->selectDescendantsOfType('n_NEW');
 foreach ($uses_of_new as $new_operator) {
   $name = $new_operator->getChildByIndex(0);
   if ($name->getTypeName() === 'n_VARIABLE' ||
       $name->getTypeName() === 'n_VARIABLE_VARIABLE') {
     continue;
   }
   $need[] = array(
     'type'    => 'class',
     'symbol'  => $name,
   );
 }
 
 // This covers all of "X::$y", "X::y()" and "X::CONST".
 $static_uses = $root->selectDescendantsOfType('n_CLASS_STATIC_ACCESS');
 foreach ($static_uses as $static_use) {
   $name = $static_use->getChildByIndex(0);
   if ($name->getTypeName() !== 'n_CLASS_NAME') {
     continue;
   }
   $need[] = array(
     'type'    => 'class',
     'symbol'  => $name,
   );
 }
 
 // This is "function (X $x)".
 $parameters = $root->selectDescendantsOfType('n_DECLARATION_PARAMETER');
 foreach ($parameters as $parameter) {
   $hint = $parameter->getChildByIndex(0);
   if ($hint->getTypeName() !== 'n_CLASS_NAME') {
     continue;
   }
   $need[] = array(
     'type'    => 'class/interface',
     'symbol'  => $hint,
   );
 }
 
 $returns = $root->selectDescendantsOfType('n_DECLARATION_RETURN');
 foreach ($returns as $return) {
   $hint = $return->getChildByIndex(0);
   if ($hint->getTypeName() !== 'n_CLASS_NAME') {
     continue;
   }
   $need[] = array(
     'type'   => 'class/interface',
     'symbol' => $hint,
   );
 }
 
 // This is "catch (Exception $ex)".
 $catches = $root->selectDescendantsOfType('n_CATCH');
 foreach ($catches as $catch) {
   $need[] = array(
     'type'    => 'class/interface',
     'symbol'  => $catch->getChildOfType(0, 'n_CLASS_NAME'),
   );
 }
 
 // This is "$x instanceof X".
 $instanceofs = $root->selectDescendantsOfType('n_BINARY_EXPRESSION');
 foreach ($instanceofs as $instanceof) {
   $operator = $instanceof->getChildOfType(1, 'n_OPERATOR');
   if ($operator->getConcreteString() !== 'instanceof') {
     continue;
   }
   $class = $instanceof->getChildByIndex(2);
   if ($class->getTypeName() !== 'n_CLASS_NAME') {
     continue;
   }
   $need[] = array(
     'type'    => 'class/interface',
     'symbol'  => $class,
   );
 }
 
 // This is "newv('X')".
 $calls = $root->selectDescendantsOfType('n_FUNCTION_CALL');
 foreach ($calls as $call) {
   $call_name = $call->getChildByIndex(0)->getConcreteString();
   if ($call_name !== 'newv') {
     continue;
   }
   $params = $call->getChildByIndex(1)->getChildren();
   if (!count($params)) {
     continue;
   }
   $symbol = reset($params);
   $symbol_value = $symbol->getStringLiteralValue();
   if ($symbol_value && strpos($symbol_value, '$') === false) {
     $need[] = array(
       'type'    => 'class',
       'name'    => $symbol_value,
       'symbol'  => $symbol,
     );
   }
 }
 
 
 // -(  Interfaces  )------------------------------------------------------------
 
 
 // Find interfaces declared in this file.
 
 
 // This is "interface X .. { ... }".
 $interfaces = $root->selectDescendantsOfType('n_INTERFACE_DECLARATION');
 foreach ($interfaces as $interface) {
   $interface_name = $interface->getChildByIndex(1);
   $have[] = array(
     'type'    => 'interface',
     'symbol'  => $interface_name,
   );
 }
 
 
 // Find interfaces used by this file. We identify these:
 //
 //  - class ... implements X
 //  - interface ... extends X
 
 
 // This is "class X ... { ... }".
 $classes = $root->selectDescendantsOfType('n_CLASS_DECLARATION');
 foreach ($classes as $class) {
   $class_name = $class->getChildByIndex(1)->getConcreteString();
   $implements = $class->getChildByIndex(3);
   $interfaces = $implements->selectDescendantsOfType('n_CLASS_NAME');
   foreach ($interfaces as $interface) {
     $need[] = array(
       'type'    => 'interface',
       'symbol'  => $interface,
     );
 
     // Track 'class ... implements' in the extension map.
     $xmap[$class_name][] = $interface->getConcreteString();
   }
 }
 
 
 // This is "interface X ... { ... }".
 $interfaces = $root->selectDescendantsOfType('n_INTERFACE_DECLARATION');
 foreach ($interfaces as $interface) {
   $interface_name = $interface->getChildByIndex(1)->getConcreteString();
 
   $extends = $interface->getChildByIndex(2);
   foreach ($extends->selectDescendantsOfType('n_CLASS_NAME') as $parent) {
     $need[] = array(
       'type'    => 'interface',
       'symbol'  => $parent,
     );
 
     // Track 'interface ... extends' in the extension map.
     $xmap[$interface_name][] = $parent->getConcreteString();
   }
 }
 
 
 // -(  Analysis  )--------------------------------------------------------------
 
 
 $declared_symbols = array();
 foreach ($have as $key => $spec) {
   $name = $spec['symbol']->getConcreteString();
   $declared_symbols[$spec['type']][$name] = $spec['symbol']->getOffset();
 }
 
 $required_symbols = array();
 foreach ($need as $key => $spec) {
   $name = idx($spec, 'name');
   if (!$name) {
     $name = $spec['symbol']->getConcreteString();
   }
 
   $type = $spec['type'];
   foreach (explode('/', $type) as $libtype) {
     if (!$show_all) {
       if (!empty($externals[$libtype][$name])) {
         // Ignore symbols declared as externals.
         continue 2;
       }
       if (!empty($builtins[$libtype][$name])) {
         // Ignore symbols declared as builtins.
         continue 2;
       }
     }
     if (!empty($declared_symbols[$libtype][$name])) {
       // We declare this symbol, so don't treat it as a requirement.
       continue 2;
     }
   }
   if (!empty($required_symbols[$type][$name])) {
     // Report only the first use of a symbol, since reporting all of them
     // isn't terribly informative.
     continue;
   }
   $required_symbols[$type][$name] = $spec['symbol']->getOffset();
 }
 
 $result = array(
   'have'  => $declared_symbols,
   'need'  => $required_symbols,
   'xmap'  => $xmap,
 );
 
 
 // -(  Output  )----------------------------------------------------------------
 
 
 if ($args->getArg('ugly')) {
   echo json_encode($result);
 } else {
   $json = new PhutilJSON();
   echo $json->encodeFormatted($result);
 }
 
 
 // -(  Library  )---------------------------------------------------------------
 
 function phutil_fail_on_unsupported_feature(XHPASTNode $node, $file, $what) {
   $line = $node->getLineNumber();
   $message = phutil_console_wrap(
     pht(
       '`%s` has limited support for features introduced after PHP 5.2.3. '.
       'This library uses an unsupported feature (%s) on line %d of %s.',
       'arc liberate',
       $what,
       $line,
       Filesystem::readablePath($file)));
 
   $result = array(
     'error' => $message,
     'line'  => $line,
     'file'  => $file,
   );
   $json = new PhutilJSON();
   echo $json->encodeFormatted($result);
   exit(0);
 }
 
 function phutil_symbols_get_builtins() {
   $builtin = array();
   $builtin['classes']    = get_declared_classes();
   $builtin['interfaces'] = get_declared_interfaces();
 
   $funcs = get_defined_functions();
   $builtin['functions']  = $funcs['internal'];
 
   $compat = json_decode(
     file_get_contents(
       dirname(__FILE__).'/../../resources/php/symbol-information.json'),
     true);
 
   foreach (array('functions', 'classes', 'interfaces') as $type) {
     // Developers may not have every extension that a library potentially uses
     // installed. We supplement the list of declared functions and classes with
     // a list of known extension functions to avoid raising false positives just
     // because you don't have pcntl, etc.
     $extensions = array_keys($compat[$type]);
     $builtin[$type] = array_merge($builtin[$type], $extensions);
   }
 
   return array(
     'class'     => array_fill_keys($builtin['classes'], true) + array(
       'static' => true,
       'parent' => true,
       'self'   => true,
 
       'PhutilBootloader' => true,
 
       // PHP7 defines these new parent classes of "Exception", but they do not
       // exist prior to PHP7. It's possible to use them safely in PHP5, in
       // some cases, to write code which is compatible with either PHP5 or
       // PHP7, but it's hard for us tell if a particular use is safe or not.
       // For now, assume users know what they're doing and that uses are safe.
       // For discussion, see T12855.
       'Throwable' => true,
       'Error' => true,
       'ParseError' => true,
 
       // PHP7 types.
       'bool' => true,
       'float' => true,
       'int' => true,
       'string' => true,
       'iterable' => true,
       'object' => true,
       'void' => true,
     ),
     'function'  => array_filter(
       array(
         'empty' => true,
         'isset' => true,
         'die'   => true,
 
         // These are provided by libphutil but not visible in the map.
 
         'phutil_is_windows'   => true,
         'phutil_load_library' => true,
         'phutil_is_hiphop_runtime' => true,
 
         // HPHP/i defines these functions as 'internal', but they are NOT
         // builtins and do not exist in vanilla PHP. Make sure we don't mark
         // them as builtin since we need to add dependencies for them.
         'idx'   => false,
         'id'    => false,
       ) + array_fill_keys($builtin['functions'], true)),
     'interface' => array_fill_keys($builtin['interfaces'], true),
   );
 }
diff --git a/support/lib/rebuild-map.php b/support/lib/rebuild-map.php
index 533f7806..66c1c8be 100755
--- a/support/lib/rebuild-map.php
+++ b/support/lib/rebuild-map.php
@@ -1,78 +1,78 @@
 #!/usr/bin/env php
 <?php
 
 $root = dirname(dirname(dirname(__FILE__)));
-require_once $root.'/scripts/init/init-script.php';
+require_once $root.'/support/init/init-script.php';
 
 $args = new PhutilArgumentParser($argv);
 $args->setTagline(pht('rebuild the library map file'));
 $args->setSynopsis(<<<EOHELP
     **rebuild-map.php** [__options__] __root__
         Rebuild the library map file for a libphutil library.
 
 EOHELP
 );
 
 $args->parseStandardArguments();
 $args->parse(
   array(
     array(
       'name'      => 'quiet',
       'help'      => pht('Do not write status messages to stderr.'),
     ),
     array(
       'name'      => 'drop-cache',
       'help'      => pht(
         'Drop the symbol cache and rebuild the entire map from scratch.'),
     ),
     array(
       'name'      => 'limit',
       'param'     => 'N',
       'default'   => 8,
       'help'      => pht(
         'Controls the number of symbol mapper subprocesses run at once. '.
         'Defaults to 8.'),
     ),
     array(
       'name'      => 'show',
       'help'      => pht(
         'Print symbol map to stdout instead of writing it to the map file.'),
     ),
     array(
       'name'      => 'ugly',
       'help'      => pht(
         'Use faster but less readable serialization for "--show".'),
     ),
     array(
       'name'      => 'root',
       'wildcard'  => true,
     ),
   ));
 
 $root = $args->getArg('root');
 if (count($root) !== 1) {
   throw new Exception(pht('Provide exactly one library root!'));
 }
 $root = Filesystem::resolvePath(head($root));
 
 $builder = new PhutilLibraryMapBuilder($root);
 $builder->setQuiet($args->getArg('quiet'));
 $builder->setSubprocessLimit($args->getArg('limit'));
 
 if ($args->getArg('drop-cache')) {
   $builder->dropSymbolCache();
 }
 
 if ($args->getArg('show')) {
   $library_map = $builder->buildMap();
 
   if ($args->getArg('ugly')) {
     echo json_encode($library_map);
   } else {
     echo id(new PhutilJSON())->encodeFormatted($library_map);
   }
 } else {
   $builder->buildAndWriteMap();
 }
 
 exit(0);
diff --git a/support/shell/hooks/bash-completion.sh b/support/shell/hooks/bash-completion.sh
new file mode 100644
index 00000000..edf34f7e
--- /dev/null
+++ b/support/shell/hooks/bash-completion.sh
@@ -0,0 +1,9 @@
+SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"
+
+# Try to generate the shell completion rules if they do not yet exist.
+if [ ! -f "${SCRIPTDIR}/bash-rules.sh" ]; then
+  arc shell-complete --generate >/dev/null 2>/dev/null
+fi;
+
+# Source the shell completion rules.
+source "${SCRIPTDIR}/../rules/bash-rules.sh"
diff --git a/support/shell/rules/.keep b/support/shell/rules/.keep
new file mode 100644
index 00000000..e69de29b
diff --git a/support/shell/templates/bash-template.sh b/support/shell/templates/bash-template.sh
new file mode 100644
index 00000000..e2e8047e
--- /dev/null
+++ b/support/shell/templates/bash-template.sh
@@ -0,0 +1,22 @@
+_arcanist_complete_{{{BIN}}} ()
+{
+  COMPREPLY=()
+
+  RESULT=$(echo | {{{BIN}}} shell-complete \
+    --current ${COMP_CWORD} \
+    -- \
+    "${COMP_WORDS[@]}" \
+    2>/dev/null)
+
+  if [ $? -ne 0 ]; then
+    return $?
+  fi
+
+  if [ "$RESULT" == "<compgen:file>" ]; then
+    RESULT=$( compgen -A file -- ${COMP_WORDS[COMP_CWORD]} )
+  fi
+
+  local IFS=$'\n'
+  COMPREPLY=( $RESULT )
+}
+complete -F _arcanist_complete_{{{BIN}}} -o filenames {{{BIN}}}
diff --git a/support/unit/cat.php b/support/unit/cat.php
new file mode 100755
index 00000000..4b5ef5c1
--- /dev/null
+++ b/support/unit/cat.php
@@ -0,0 +1,4 @@
+#!/usr/bin/env php
+<?php
+
+echo file_get_contents('php://stdin');
diff --git a/support/unit/echo.php b/support/unit/echo.php
new file mode 100755
index 00000000..37bf7e53
--- /dev/null
+++ b/support/unit/echo.php
@@ -0,0 +1,9 @@
+#!/usr/bin/env php
+<?php
+
+$args = array_slice($argv, 1);
+foreach ($args as $key => $arg) {
+  $args[$key] = addcslashes($arg, "\\\n");
+}
+$args = implode("\n", $args);
+echo $args;
diff --git a/support/unit/exit.php b/support/unit/exit.php
new file mode 100755
index 00000000..9983bd17
--- /dev/null
+++ b/support/unit/exit.php
@@ -0,0 +1,4 @@
+#!/usr/bin/env php
+<?php
+
+exit(0);
diff --git a/support/test/lock-file.php b/support/unit/lock.php
old mode 100644
new mode 100755
similarity index 93%
rename from support/test/lock-file.php
rename to support/unit/lock.php
index b7ec9df3..b4e13a60
--- a/support/test/lock-file.php
+++ b/support/unit/lock.php
@@ -1,82 +1,83 @@
 #!/usr/bin/env php
 <?php
 
-require_once dirname(__FILE__).'/../../scripts/init/init-script.php';
+$arcanist_root = dirname(dirname(dirname(__FILE__)));
+require_once $arcanist_root.'/support/init/init-script.php';
 
 $args = new PhutilArgumentParser($argv);
 $args->setTagline(pht('acquire and hold a lockfile'));
 $args->setSynopsis(<<<EOHELP
 **lock.php** __file__ [__options__]
     Acquire a lockfile and hold it until told to unlock it.
 
 EOHELP
 );
 
 $args->parseStandardArguments();
 $args->parse(array(
   array(
     'name'      => 'test',
     'help'      => pht('Instead of holding the lock, release it and exit.'),
   ),
   array(
     'name'      => 'hold',
     'help'      => pht('Hold indefinitely without prompting.'),
   ),
   array(
     'name'      => 'wait',
     'param'     => 'n',
     'help'      => pht('Block for up to __n__ seconds waiting for the lock.'),
     'default'   => 0,
   ),
   array(
     'name'      => 'file',
     'wildcard'  => true,
   ),
 ));
 
 
 $file = $args->getArg('file');
 if (count($file) !== 1) {
   $args->printHelpAndExit();
 }
 $file = head($file);
 
 $console = PhutilConsole::getConsole();
 $console->writeOut(
   "%s\n",
   pht('This process has PID %d. Acquiring lock...', getmypid()));
 
 $lock = PhutilFileLock::newForPath($file);
 
 try {
   $lock->lock($args->getArg('wait'));
 } catch (PhutilFileLockException $ex) {
   $console->writeOut(
     "**%s** %s\n",
     pht('UNABLE TO ACQUIRE LOCK:'),
     pht('Lock is already held.'));
   exit(1);
 }
 
 // NOTE: This string is magic, the unit tests look for it.
 $console->writeOut("%s\n", pht('LOCK ACQUIRED'));
 if ($args->getArg('test')) {
   $lock->unlock();
   exit(0);
 }
 
 if ($args->getArg('hold')) {
   while (true) {
     sleep(1);
   }
 }
 
 while (!$console->confirm(pht('Release lock?'))) {
   // Keep asking until they say yes.
 }
 
 $console->writeOut("%s\n", pht('Unlocking...'));
 $lock->unlock();
 
 $console->writeOut("%s\n", pht('Done.'));
 exit(0);
diff --git a/support/unit/sleep.php b/support/unit/sleep.php
new file mode 100755
index 00000000..fbdf4144
--- /dev/null
+++ b/support/unit/sleep.php
@@ -0,0 +1,20 @@
+<?php
+
+if ($argc != 2) {
+  echo "usage: sleep <duration>\n";
+  exit(1);
+}
+
+// NOTE: Sleep for the requested duration even if our actual sleep() call is
+// interrupted by a signal.
+
+$then = microtime(true) + (double)$argv[1];
+while (true) {
+  $now = microtime(true);
+  if ($now >= $then) {
+    break;
+  }
+
+  $sleep = max(1, ($then - $now));
+  usleep((int)($sleep * 1000000));
+}
diff --git a/support/xhpast/build-xhpast.php b/support/xhpast/build-xhpast.php
index 4f13142a..f57ee047 100755
--- a/support/xhpast/build-xhpast.php
+++ b/support/xhpast/build-xhpast.php
@@ -1,9 +1,9 @@
 #!/usr/bin/env php
 <?php
 
 $root = dirname(dirname(dirname(__FILE__)));
-require_once $root.'/scripts/init/init-script.php';
+require_once $root.'/support/init/init-script.php';
 
 PhutilXHPASTBinary::build();
 
 echo pht('Build successful!')."\n";