diff --git a/scripts/phutil_rebuild_map.php b/scripts/phutil_rebuild_map.php
index 865f30dc..53d5ee1a 100755
--- a/scripts/phutil_rebuild_map.php
+++ b/scripts/phutil_rebuild_map.php
@@ -1,588 +1,588 @@
 #!/usr/bin/env php
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 require_once dirname(__FILE__).'/__init_script__.php';
 
 $args = new PhutilArgumentParser($argv);
 $args->setTagline('rebuild the library map file');
 $args->setSynopsis(<<<EOHELP
     **phutil_rebuild_map.php** [__options__] __root__
         Rebuild the library map file for a libphutil library.
 
 EOHELP
 );
 
 $args->parseStandardArguments();
 $args->parse(
   array(
     array(
       'name'      => 'quiet',
       'help'      => 'Do not write status messages to stderr.',
     ),
     array(
       'name'      => 'drop-cache',
       'help'      => 'Drop the symbol cache and rebuild the entire map from '.
                      'scratch.',
     ),
     array(
       'name'      => 'limit',
       'param'     => 'N',
       'default'   => 8,
       'help'      => 'Controls the number of symbol mapper subprocesses run '.
                      'at once. Defaults to 8.',
     ),
     array(
       'name'      => 'show',
       'help'      => 'Print symbol map to stdout instead of writing it to the '.
                      'map file.',
     ),
     array(
       'name'      => 'ugly',
       'help'      => 'Use faster but less readable serialization for --show.',
     ),
     array(
       'name'      => 'root',
       'wildcard'  => true,
     )
   ));
 
 $root = $args->getArg('root');
 if (count($root) !== 1) {
   throw new Exception("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')) {
   $builder->setShowMap(true);
   $builder->setUgly($args->getArg('ugly'));
 }
 
 $builder->buildMap();
 
 exit(0);
 
 
 
 
 /**
  * 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 {
 
   private $root;
   private $quiet;
   private $subprocessLimit = 8;
   private $ugly;
   private $showMap;
 
   const LIBRARY_MAP_VERSION_KEY   = '__library_version__';
   const LIBRARY_MAP_VERSION       = 2;
 
   const SYMBOL_CACHE_VERSION_KEY  = '__symbol_cache_version__';
   const SYMBOL_CACHE_VERSION      = 2;
 
 
 /* -(  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;
   }
 
 
   /**
    * Control whether the ugly (but fast) or pretty (but slower) JSON formatter
    * is used.
    *
    * @param   bool  If true, use the fastest formatter.
    * @return  this
    *
    * @task map
    */
   public function setUgly($ugly) {
     $this->ugly = $ugly;
     return $this;
   }
 
 
   /**
    * Control whether the map should be rebuilt, or just shown (printed to
    * stdout in JSON).
    *
    * @param bool  If true, show map instead of updating.
    * @return this
    *
    * @task map
    */
   public function setShowMap($show_map) {
     $this->showMap = $show_map;
     return $this;
   }
 
 
   /**
    * Build or rebuild the library map.
    *
    * @return this
    *
    * @task map
    */
   public function buildMap() {
 
     // Identify all the ".php" source files in the library.
     $this->log("Finding source files...\n");
     $source_map = $this->loadSourceFileMap();
     $this->log("Found ".number_format(count($source_map))." files.\n");
 
 
     // Load the symbol cache with existing parsed symbols. This allows us
     // to remap libraries quickly by analyzing only changed files.
     $this->log("Loading symbol cache...\n");
     $symbol_cache = $this->loadSymbolCache();
 
 
     // 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("Found ".number_format(count($symbol_map))." files in cache.\n");
 
 
     // Run the analyzer on any files which need analysis.
     if ($futures) {
       $limit = $this->subprocessLimit;
       $count = number_format(count($futures));
 
       $this->log("Analyzing {$count} files with {$limit} subprocesses...\n");
 
       foreach (Futures($futures)->limit($limit) as $file => $future) {
         $result = $future->resolveJSON();
         if (empty($result['error'])) {
           $symbol_map[$file] = $result;
         } else {
           echo phutil_console_format(
             "\n**SYNTAX ERROR!**\nFile: %s\nLine: %d\n\n%s\n",
             Filesystem::readablePath($result['file']),
             $result['line'],
             $result['error']);
           exit(1);
         }
         $this->log(".");
       }
       $this->log("\nDone.\n");
     }
 
 
     // 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.
 
     if ($this->showMap) {
       $this->log("Showing map...\n");
 
       if ($this->ugly) {
         echo json_encode($symbol_map);
       } else {
         $json = new PhutilJSON();
         echo $json->encodeFormatted($symbol_map);
       }
     } else {
       $this->log("Building library map...\n");
-      $library_map = $this->buildLibraryMap($symbol_map, $source_map);
+      $library_map = $this->buildLibraryMap($symbol_map);
 
       $this->log("Writing map...\n");
       $this->writeLibraryMap($library_map);
     }
 
     $this->log("Done.\n");
 
     return $this;
   }
 
 
   /**
    * 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, $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`.
    *
    * @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) {
       $symbol_cache = json_decode($cache, true);
       if (!is_array($symbol_cache)) {
         $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);
     Filesystem::writeFile($cache_file, $json);
   }
 
 
   /**
    * Drop the symbol cache, forcing a clean rebuild.
    *
    * @return this
    *
    * @task symbol
    */
   public function dropSymbolCache() {
     $this->log("Dropping symbol cache...\n");
     Filesystem::remove($this->getPathForSymbolCache());
   }
 
 
   /**
    * Build a future which returns a `phutil_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__).'/phutil_symbols.php';
 
     return new ExecFuture('%s --ugly -- %s', $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("Provided path '{$root}' is not a phutil library.");
     }
 
     $files = id(new FileFinder($root))
       ->withType('f')
       ->withSuffix('php')
       ->excludePath('*/.*')
       ->setGenerateChecksums(true)
       ->find();
 
     $map = array();
     foreach ($files as $file => $hash) {
       if (basename($file) == '__init__.php') {
         // TODO: Remove this once we kill __init__.php. This just makes the
         // script run faster until we do, so testing and development is less
         // annoying.
         continue;
       }
 
       $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;
       }
 
       $map[$file] = $hash;
     }
 
     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(
               "Definition of {$type} '{$symbol}' in file '{$file}' duplicates ".
               "prior definition in file '{$prior}'. You can not declare the ".
               "same symbol twice.");
           }
           $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 = var_export($library_map, $return_string = true);
     $library_map = preg_replace('/\s+$/m', '', $library_map);
     $library_map = preg_replace('/array \(/', 'array(', $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);
   }
 
 }
diff --git a/src/hgdaemon/ArcanistHgProxyServer.php b/src/hgdaemon/ArcanistHgProxyServer.php
index 3ff9ae2e..43e0127f 100644
--- a/src/hgdaemon/ArcanistHgProxyServer.php
+++ b/src/hgdaemon/ArcanistHgProxyServer.php
@@ -1,312 +1,312 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Server which @{class:ArcanistHgProxyClient} clients connect to. This
  * server binds to a Mercurial working copy and creates a Mercurial process and
  * a unix domain socket in that working copy. It listens for connections on
  * the socket, reads commands from them, and forwards their requests to the
  * Mercurial process. It then returns responses to the original clients.
  *
  * Note that this server understands the underlying protocol and completely
  * decodes messages from both the client and server before re-encoding them
  * and relaying them to their final destinations. It must do this (at least
  * in part) to determine where messages begin and end. Additionally, this proxy
  * sends and receives the Mercurial cmdserver protocol exactly, without
  * any extensions or sneakiness.
  *
  * The advantage of this mechanism is that it avoids the overhead of starting
  * a Mercurial process for each Mercurial command, which can exceed 100ms per
  * invocation. This server can also accept connections from multiple clients
  * and serve them from a single Mercurial server process.
  *
  * @task construct  Construction
  * @task server     Serving Requests
  * @task client     Managing Clients
  * @task hg         Managing Mercurial
  * @task internal   Internals
  */
 final class ArcanistHgProxyServer {
 
   private $workingCopy;
   private $socket;
   private $hello;
 
 
 /* -(  Construction  )------------------------------------------------------- */
 
 
   /**
    * Build a new server. This server is bound to a working copy. The server
    * is inactive until you @{method:start} it.
    *
    * @param string Path to a Mercurial working copy.
    *
    * @task construct
    */
   public function __construct($working_copy) {
     $this->workingCopy = Filesystem::resolvePath($working_copy);
   }
 
 
 /* -(  Serving Requests  )--------------------------------------------------- */
 
 
   /**
    * Start the server. This method does not return.
    *
    * @return never
    *
    * @task server
    */
   public function start() {
 
     // Create the unix domain socket in the working copy to listen for clients.
     $socket = $this->startWorkingCopySocket();
     $this->socket = $socket;
 
     // TODO: Daemonize here.
 
     // Start the Mercurial process which we'll forward client requests to.
     $hg = $this->startMercurialProcess();
     $clients = array();
 
     $this->log(null, 'Listening');
     while (true) {
       // Wait for activity on any active clients, the Mercurial process, or
       // the listening socket where new clients connect.
       PhutilChannel::waitForAny(
         array_merge($clients, array($hg)),
         array(
           'read'    => array($socket),
           'except'  => array($socket),
         ));
 
       if (!$hg->update()) {
         throw new Exception("Server exited unexpectedly!");
       }
 
       // Accept any new clients.
       while ($client = $this->acceptNewClient($socket)) {
         $clients[] = $client;
         $key = last_key($clients);
         $client->setName($key);
 
         $this->log($client, 'Connected');
       }
 
       // Update all the active clients.
       foreach ($clients as $key => $client) {
         $ok = $this->updateClient($client, $hg);
         if (!$ok) {
           $this->log($client, 'Disconnected');
           unset($clients[$key]);
         }
       }
     }
   }
 
 
   /**
    * Update one client, processing any commands it has sent us. We fully
    * process all commands we've received here before returning to the main
    * server loop.
    *
    * @param ArcanistHgClientChannel The client to update.
    * @param ArcanistHgServerChannel The Mercurial server.
    *
    * @task server
    */
   private function updateClient(
     ArcanistHgClientChannel $client,
     ArcanistHgServerChannel $hg) {
 
     if (!$client->update()) {
       // Client has disconnected, don't bother proceeding.
       return false;
     }
 
     // Read a command from the client if one is available. Note that we stop
     // updating other clients or accepting new connections while processing a
     // command, since there isn't much we can do with them until the server
     // finishes executing this command.
     $message = $client->read();
     if (!$message) {
       return true;
     }
 
     $this->log($client, '$ '.$message[0].' '.$message[1]);
     $t_start = microtime(true);
 
     // Forward the command to the server.
     $hg->write($message);
 
     while (true) {
       PhutilChannel::waitForAny(array($client, $hg));
 
       if (!$client->update() || !$hg->update()) {
         // If either the client or server has exited, bail.
         return false;
       }
 
       $response = $hg->read();
       if (!$response) {
         continue;
       }
 
       // Forward the response back to the client.
       $client->write($response);
 
       // If the response was on the 'r'esult channel, it indicates the end
       // of the command output. We can process the next command (if any
       // remain) or go back to accepting new connections and servicing
       // other clients.
       if ($response[0] == 'r') {
         // Update the client immediately to try to get the bytes on the wire
         // as quickly as possible. This gives us slightly more throughput.
         $client->update();
         break;
       }
     }
 
     // Log the elapsed time.
     $t_end = microtime(true);
     $t = 1000000 * ($t_end - $t_start);
     $this->log($client, '< '.number_format($t, 0).'us');
 
     return true;
   }
 
 
 /* -(  Managing Clients  )--------------------------------------------------- */
 
 
   /**
    * @task client
    */
   public static function getPathToSocket($working_copy) {
     return $working_copy.'/.hg/hgdaemon-socket';
   }
 
 
   /**
    * @task client
    */
   private function startWorkingCopySocket() {
     $errno = null;
     $errstr = null;
 
     $socket_path = self::getPathToSocket($this->workingCopy);
     $socket_uri  = 'unix://'.$socket_path;
 
     $socket = @stream_socket_server($socket_uri, $errno, $errstr);
     if ($errno || !$socket) {
       Filesystem::remove($socket_path);
       $socket = @stream_socket_server($socket_uri, $errno, $errstr);
     }
 
     if ($errno || !$socket) {
       throw new Exception(
         "Unable to start socket! Error #{$errno}: {$errstr}");
     }
 
     $ok = stream_set_blocking($socket, 0);
     if ($ok === false) {
       throw new Exception("Unable to set socket nonblocking!");
     }
 
     return $socket;
   }
 
 
   /**
    * @task client
    */
   private function acceptNewClient($socket) {
     // NOTE: stream_socket_accept() always blocks, even when the socket has
     // been set nonblocking.
     $new_client = @stream_socket_accept($socket, $timeout = 0);
     if (!$new_client) {
       return;
     }
 
     $channel = new PhutilSocketChannel($new_client);
     $client = new ArcanistHgClientChannel($channel);
 
     $client->write($this->hello);
 
     return $client;
   }
 
 
 /* -(  Managing Mercurial  )------------------------------------------------- */
 
 
   /**
    * Starts a Mercurial process which can actually handle requests.
    *
    * @return ArcanistHgServerChannel  Channel to the Mercurial server.
    * @task hg
    */
   private function startMercurialProcess() {
     // NOTE: "cmdserver.log=-" makes Mercurial use the 'd'ebug channel for
     // log messages.
 
     $command = 'HGPLAIN=1 hg --config cmdserver.log=- serve --cmdserver pipe';
 
     $future = new ExecFuture($command);
     $future->setCWD($this->workingCopy);
 
     $channel = new PhutilExecChannel($future);
     $hg = new ArcanistHgServerChannel($channel);
 
     // The server sends a "hello" message with capability and encoding
     // information. Save it and forward it to clients when they connect.
     $this->hello = $hg->waitForMessage();
 
     return $hg;
   }
 
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Close and remove the unix domain socket in the working copy.
    *
    * @task internal
    */
   public function __destruct() {
     if ($this->socket) {
-      @stream_socket_shutdown($this->socket);
+      @stream_socket_shutdown($this->socket, STREAM_SHUT_RDWR);
       @fclose($this->socket);
       Filesystem::remove(self::getPathToSocket($this->workingCopy));
       $this->socket = null;
     }
   }
 
   private function log($client, $message) {
     if ($client) {
       $message = '[Client '.$client->getName().'] '.$message;
     } else {
       $message = '[Server] '.$message;
     }
     echo $message."\n";
   }
 
 }
diff --git a/src/parser/ArcanistBundle.php b/src/parser/ArcanistBundle.php
index dec839c4..2eb3d9d9 100644
--- a/src/parser/ArcanistBundle.php
+++ b/src/parser/ArcanistBundle.php
@@ -1,732 +1,732 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Converts changesets between different formats.
  *
  * @group diff
  */
 final class ArcanistBundle {
 
   private $changes;
   private $conduit;
   private $blobs = array();
   private $diskPath;
   private $projectID;
   private $baseRevision;
   private $revisionID;
   private $encoding;
   private $loadFileDataCallback;
 
   public function setConduit(ConduitClient $conduit) {
     $this->conduit = $conduit;
     return $this;
   }
 
   public function setProjectID($project_id) {
     $this->projectID = $project_id;
     return $this;
   }
 
   public function getProjectID() {
     return $this->projectID;
   }
 
   public function setBaseRevision($base_revision) {
     $this->baseRevision = $base_revision;
     return $this;
   }
 
   public function setEncoding($encoding) {
     $this->encoding = $encoding;
     return $this;
   }
 
   public function getEncoding() {
     return $this->encoding;
   }
 
   public function getBaseRevision() {
     return $this->baseRevision;
   }
 
   public function setRevisionID($revision_id) {
     $this->revisionID = $revision_id;
     return $this;
   }
 
   public function getRevisionID() {
     return $this->revisionID;
   }
 
   public static function newFromChanges(array $changes) {
     $obj = new ArcanistBundle();
     $obj->changes = $changes;
     return $obj;
   }
 
   public static function newFromArcBundle($path) {
     $path = Filesystem::resolvePath($path);
 
     $future = new ExecFuture(
       csprintf(
         'tar tfO %s',
         $path));
     list($stdout, $file_list) = $future->resolvex();
     $file_list = explode("\n", trim($file_list));
 
     if (in_array('meta.json', $file_list)) {
       $future = new ExecFuture(
         csprintf(
           'tar xfO %s meta.json',
           $path));
       $meta_info = $future->resolveJSON();
       $version       = idx($meta_info, 'version', 0);
       $project_name  = idx($meta_info, 'projectName');
       $base_revision = idx($meta_info, 'baseRevision');
       $revision_id   = idx($meta_info, 'revisionID');
       $encoding      = idx($meta_info, 'encoding');
     // this arc bundle was probably made before we started storing meta info
     } else {
       $version       = 0;
       $project_name  = null;
       $base_revision = null;
       $revision_id   = null;
       $encoding      = null;
     }
 
     $future = new ExecFuture(
       csprintf(
         'tar xfO %s changes.json',
         $path));
     $changes = $future->resolveJSON();
 
     foreach ($changes as $change_key => $change) {
       foreach ($change['hunks'] as $key => $hunk) {
         list($hunk_data) = execx('tar xfO %s hunks/%s', $path, $hunk['corpus']);
         $changes[$change_key]['hunks'][$key]['corpus'] = $hunk_data;
       }
     }
 
     foreach ($changes as $change_key => $change) {
       $changes[$change_key] = ArcanistDiffChange::newFromDictionary($change);
     }
 
     $obj = new ArcanistBundle();
     $obj->changes = $changes;
     $obj->diskPath = $path;
     $obj->setProjectID($project_name);
     $obj->setBaseRevision($base_revision);
     $obj->setRevisionID($revision_id);
     $obj->setEncoding($encoding);
 
     return $obj;
   }
 
   public static function newFromDiff($data) {
     $obj = new ArcanistBundle();
 
     $parser = new ArcanistDiffParser();
     $obj->changes = $parser->parseDiff($data);
 
     return $obj;
   }
 
   private function __construct() {
 
   }
 
   public function writeToDisk($path) {
     $changes = $this->getChanges();
 
     $change_list = array();
     foreach ($changes as $change) {
       $change_list[] = $change->toDictionary();
     }
 
     $hunks = array();
     foreach ($change_list as $change_key => $change) {
       foreach ($change['hunks'] as $key => $hunk) {
         $hunks[] = $hunk['corpus'];
         $change_list[$change_key]['hunks'][$key]['corpus'] = count($hunks) - 1;
       }
     }
 
     $blobs = array();
     foreach ($change_list as $change) {
       if (!empty($change['metadata']['old:binary-phid'])) {
         $blobs[$change['metadata']['old:binary-phid']] = null;
       }
       if (!empty($change['metadata']['new:binary-phid'])) {
         $blobs[$change['metadata']['new:binary-phid']] = null;
       }
     }
     foreach ($blobs as $phid => $null) {
       $blobs[$phid] = $this->getBlob($phid);
     }
 
     $meta_info = array(
       'version'      => 3,
       'projectName'  => $this->getProjectID(),
       'baseRevision' => $this->getBaseRevision(),
       'revisionID'   => $this->getRevisionID(),
       'encoding'     => $this->getEncoding(),
     );
 
     $dir = Filesystem::createTemporaryDirectory();
     Filesystem::createDirectory($dir.'/hunks');
     Filesystem::createDirectory($dir.'/blobs');
     Filesystem::writeFile($dir.'/changes.json', json_encode($change_list));
     Filesystem::writeFile($dir.'/meta.json', json_encode($meta_info));
     foreach ($hunks as $key => $hunk) {
       Filesystem::writeFile($dir.'/hunks/'.$key, $hunk);
     }
     foreach ($blobs as $key => $blob) {
       Filesystem::writeFile($dir.'/blobs/'.$key, $blob);
     }
     execx(
       '(cd %s; tar -czf %s *)',
       $dir,
       Filesystem::resolvePath($path));
     Filesystem::remove($dir);
   }
 
   public function toUnifiedDiff() {
 
     $result = array();
     $changes = $this->getChanges();
     foreach ($changes as $change) {
 
       $old_path = $this->getOldPath($change);
       $cur_path = $this->getCurrentPath($change);
 
       $index_path = $cur_path;
       if ($index_path === null) {
         $index_path = $old_path;
       }
 
       $result[] = 'Index: '.$index_path;
       $result[] = str_repeat('=', 67);
 
       if ($old_path === null) {
         $old_path = '/dev/null';
       }
 
       if ($cur_path === null) {
         $cur_path = '/dev/null';
       }
 
       // When the diff is used by `patch`, `patch` ignores what is listed as the
       // current path and just makes changes to the file at the old path (unless
       // the current path is '/dev/null'.
       // If the old path and the current path aren't the same (and neither is
       // /dev/null), this indicates the file was moved or copied. By listing
       // both paths as the new file, `patch` will apply the diff to the new
       // file.
       if ($cur_path !== '/dev/null' && $old_path !== '/dev/null') {
         $old_path = $cur_path;
       }
 
       $result[] = '--- '.$old_path;
       $result[] = '+++ '.$cur_path;
 
       $result[] = $this->buildHunkChanges($change->getHunks());
     }
 
     $diff = implode("\n", $result)."\n";
     return $this->convertNonUTF8Diff($diff);
   }
 
   public function toGitPatch() {
     $result = array();
     $changes = $this->getChanges();
 
     foreach (array_keys($changes) as $multicopy_key) {
       $multicopy_change = $changes[$multicopy_key];
 
       $type = $multicopy_change->getType();
       if ($type != ArcanistDiffChangeType::TYPE_MULTICOPY) {
         continue;
       }
 
       // Decompose MULTICOPY into one MOVE_HERE and several COPY_HERE because
       // we need more information than we have in order to build a delete patch
       // and represent it as a bunch of COPY_HERE plus a delete. For details,
       // see T419.
 
       // Basically, MULTICOPY means there are 2 or more corresponding COPY_HERE
       // changes, so find one of them arbitrariy and turn it into a MOVE_HERE.
 
       // TODO: We might be able to do this more cleanly after T230 is resolved.
 
       $decompose_okay = false;
       foreach ($changes as $change_key => $change) {
         if ($change->getType() != ArcanistDiffChangeType::TYPE_COPY_HERE) {
           continue;
         }
         if ($change->getOldPath() != $multicopy_change->getCurrentPath()) {
           continue;
         }
         $decompose_okay = true;
         $change = clone $change;
         $change->setType(ArcanistDiffChangeType::TYPE_MOVE_HERE);
         $changes[$change_key] = $change;
 
         // The multicopy is now fully represented by MOVE_HERE plus one or more
         // COPY_HERE, so throw it away.
         unset($changes[$multicopy_key]);
         break;
       }
 
       if (!$decompose_okay) {
         throw new Exception(
           "Failed to decompose multicopy changeset in order to generate diff.");
       }
     }
 
     foreach ($changes as $change) {
       $type = $change->getType();
       $file_type = $change->getFileType();
 
       if ($file_type == ArcanistDiffChangeType::FILE_DIRECTORY) {
         // TODO: We should raise a FYI about this, so the user is aware
         // that we omitted it, if the directory is empty or has permissions
         // which git can't represent.
 
         // Git doesn't support empty directories, so we simply ignore them. If
         // the directory is nonempty, 'git apply' will create it when processing
         // the changesets for files inside it.
         continue;
       }
 
       if ($type == ArcanistDiffChangeType::TYPE_MOVE_AWAY) {
         // Git will apply this in the corresponding MOVE_HERE.
         continue;
       }
 
       $old_mode = idx($change->getOldProperties(), 'unix:filemode', '100644');
       $new_mode = idx($change->getNewProperties(), 'unix:filemode', '100644');
 
       $is_binary = ($file_type == ArcanistDiffChangeType::FILE_BINARY ||
                     $file_type == ArcanistDiffChangeType::FILE_IMAGE);
 
       if ($is_binary) {
         $change_body = $this->buildBinaryChange($change);
       } else {
         $change_body = $this->buildHunkChanges($change->getHunks());
       }
       if ($type == ArcanistDiffChangeType::TYPE_COPY_AWAY) {
         // TODO: This is only relevant when patching old Differential diffs
         // which were created prior to arc pruning TYPE_COPY_AWAY for files
         // with no modifications.
         if (!strlen($change_body) && ($old_mode == $new_mode)) {
           continue;
         }
       }
 
       $old_path = $this->getOldPath($change);
       $cur_path = $this->getCurrentPath($change);
 
       if ($old_path === null) {
         $old_index = 'a/'.$cur_path;
         $old_target  = '/dev/null';
       } else {
         $old_index = 'a/'.$old_path;
         $old_target  = 'a/'.$old_path;
       }
 
       if ($cur_path === null) {
         $cur_index = 'b/'.$old_path;
         $cur_target  = '/dev/null';
       } else {
         $cur_index = 'b/'.$cur_path;
         $cur_target  = 'b/'.$cur_path;
       }
 
       $result[] = "diff --git {$old_index} {$cur_index}";
 
       if ($type == ArcanistDiffChangeType::TYPE_ADD) {
         $result[] = "new file mode {$new_mode}";
       }
 
       if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE ||
           $type == ArcanistDiffChangeType::TYPE_MOVE_HERE ||
           $type == ArcanistDiffChangeType::TYPE_COPY_AWAY) {
         if ($old_mode !== $new_mode) {
           $result[] = "old mode {$old_mode}";
           $result[] = "new mode {$new_mode}";
         }
       }
 
       if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
         $result[] = "copy from {$old_path}";
         $result[] = "copy to {$cur_path}";
       } else if ($type == ArcanistDiffChangeType::TYPE_MOVE_HERE) {
         $result[] = "rename from {$old_path}";
         $result[] = "rename to {$cur_path}";
       } else if ($type == ArcanistDiffChangeType::TYPE_DELETE ||
                  $type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
         $old_mode = idx($change->getOldProperties(), 'unix:filemode');
         if ($old_mode) {
           $result[] = "deleted file mode {$old_mode}";
         }
       }
 
       if (!$is_binary) {
         $result[] = "--- {$old_target}";
         $result[] = "+++ {$cur_target}";
       }
       $result[] = $change_body;
     }
 
     $diff = implode("\n", $result)."\n";
     return $this->convertNonUTF8Diff($diff);
   }
 
   private function convertNonUTF8Diff($diff) {
     $try_encoding_is_non_utf8 =
       ($this->encoding && strtoupper($this->encoding) != 'UTF-8');
     if ($try_encoding_is_non_utf8) {
       $diff = mb_convert_encoding($diff, $this->encoding, 'UTF-8');
       if (!$diff) {
         throw new Exception(
           "Attempted conversion of diff to encoding ".
           "'{$this->encoding}' failed. Have you specified ".
           "the proper encoding correctly?");
       }
     }
     return $diff;
   }
 
   public function getChanges() {
     return $this->changes;
   }
 
   private function breakHunkIntoSmallHunks(ArcanistDiffHunk $base_hunk) {
     $context = 3;
 
     $results = array();
     $lines = explode("\n", $base_hunk->getCorpus());
     $n = count($lines);
 
     $old_offset = $base_hunk->getOldOffset();
     $new_offset = $base_hunk->getNewOffset();
 
     $ii = 0;
     $jj = 0;
     while ($ii < $n) {
       // Skip lines until we find the next line with changes. Note: this skips
       // both ' ' (no changes) and '\' (no newline at end of file) lines. If we
       // don't skip the latter, we may incorrectly generate a terminal hunk
       // that has no actual change information when a file doesn't have a
       // terminal newline and not changed near the end of the file. 'patch' will
       // fail to apply the diff if we generate a hunk that does not actually
       // contain changes.
       for ($jj = $ii; $jj < $n; ++$jj) {
         $char = $lines[$jj][0];
         if ($char == '-' || $char == '+') {
           break;
         }
       }
       if ($jj >= $n) {
         break;
       }
 
       $hunk_start = max($jj - $context, 0);
 
 
       // NOTE: There are two tricky considerations here.
       // We can not generate a patch with overlapping hunks, or 'git apply'
       // rejects it after 1.7.3.4.
       // We can not generate a patch with too much trailing context, or
       // 'patch' rejects it.
       // So we need to ensure that we generate disjoint hunks, but don't
       // generate any hunks with too much context.
 
       $old_lines = 0;
       $new_lines = 0;
       $hunk_adjust = 0;
       $last_change = $jj;
       $break_here = null;
       for (; $jj < $n; ++$jj) {
         if ($lines[$jj][0] == ' ') {
 
           if ($jj - $last_change > $context) {
             if ($break_here === null) {
               // We haven't seen a change in $context lines, so this is a
               // potential place to break the hunk. However, we need to keep
               // looking in case there is another change fewer than $context
               // lines away, in which case we have to merge the hunks.
               $break_here = $jj;
             }
           }
 
           if ($jj - $last_change > (($context + 1) * 2)) {
             // We definitely aren't going to merge this with the next hunk, so
             // break out of the loop. We'll end the hunk at $break_here.
             break;
           }
         } else {
           $break_here = null;
           $last_change = $jj;
 
           if ($lines[$jj][0] == '\\') {
             // When we have a "\ No newline at end of file" line, it does not
             // contribute to either hunk length.
             ++$hunk_adjust;
           } else if ($lines[$jj][0] == '-') {
             ++$old_lines;
           } else if ($lines[$jj][0] == '+') {
             ++$new_lines;
           }
         }
       }
 
       if ($break_here !== null) {
         $jj = $break_here;
       }
 
       $hunk_length = min($jj, $n) - $hunk_start;
       $count_length = ($hunk_length - $hunk_adjust);
 
       $hunk = new ArcanistDiffHunk();
       $hunk->setOldOffset($old_offset + $hunk_start - $ii);
       $hunk->setNewOffset($new_offset + $hunk_start - $ii);
       $hunk->setOldLength($count_length - $new_lines);
       $hunk->setNewLength($count_length - $old_lines);
 
       $corpus = array_slice($lines, $hunk_start, $hunk_length);
       $corpus = implode("\n", $corpus);
       $hunk->setCorpus($corpus);
 
       $results[] = $hunk;
 
       $old_offset += ($jj - $ii) - $new_lines;
       $new_offset += ($jj - $ii) - $old_lines;
       $ii = $jj;
     }
 
     return $results;
   }
 
   private function getOldPath(ArcanistDiffChange $change) {
     $old_path = $change->getOldPath();
     $type = $change->getType();
 
     if (!strlen($old_path) ||
         $type == ArcanistDiffChangeType::TYPE_ADD) {
       $old_path = null;
     }
 
     return $old_path;
   }
 
   private function getCurrentPath(ArcanistDiffChange $change) {
     $cur_path = $change->getCurrentPath();
     $type = $change->getType();
 
     if (!strlen($cur_path) ||
         $type == ArcanistDiffChangeType::TYPE_DELETE ||
         $type == ArcanistDiffChangeType::TYPE_MULTICOPY) {
       $cur_path = null;
     }
 
     return $cur_path;
   }
 
   private function buildHunkChanges(array $hunks) {
     assert_instances_of($hunks, 'ArcanistDiffHunk');
     $result = array();
     foreach ($hunks as $hunk) {
       $small_hunks = $this->breakHunkIntoSmallHunks($hunk);
       foreach ($small_hunks as $small_hunk) {
         $o_off = $small_hunk->getOldOffset();
         $o_len = $small_hunk->getOldLength();
         $n_off = $small_hunk->getNewOffset();
         $n_len = $small_hunk->getNewLength();
         $corpus = $small_hunk->getCorpus();
 
         // NOTE: If the length is 1 it can be omitted. Since git does this,
         // we also do it so that "arc export --git" diffs are as similar to
         // real git diffs as possible, which helps debug issues.
 
         if ($o_len == 1) {
           $o_head = "{$o_off}";
         } else {
           $o_head = "{$o_off},{$o_len}";
         }
 
         if ($n_len == 1) {
           $n_head = "{$n_off}";
         } else {
           $n_head = "{$n_off},{$n_len}";
         }
 
         $result[] = "@@ -{$o_head} +{$n_head} @@";
         $result[] = $corpus;
       }
     }
     return implode("\n", $result);
   }
 
   public function setLoadFileDataCallback($callback) {
     $this->loadFileDataCallback = $callback;
     return $this;
   }
 
   private function getBlob($phid) {
     if ($this->loadFileDataCallback) {
       return call_user_func($this->loadFileDataCallback, $phid);
     }
 
     if ($this->diskPath) {
       list($blob_data) = execx('tar xfO %s blobs/%s', $this->diskPath, $phid);
       return $blob_data;
     }
 
     if ($this->conduit) {
       echo "Downloading binary data...\n";
       $data_base64 = $this->conduit->callMethodSynchronous(
         'file.download',
         array(
           'phid' => $phid,
         ));
       return base64_decode($data_base64);
     }
 
     throw new Exception("Nowhere to load blob '{$phid}' from!");
   }
 
   private function buildBinaryChange(ArcanistDiffChange $change) {
-    $old_phid = $change->getMetadata('old:binary-phid', null);
-    $new_phid = $change->getMetadata('new:binary-phid', null);
+    $old_phid = $change->getMetadata('old:binary-phid');
+    $new_phid = $change->getMetadata('new:binary-phid');
 
     $type = $change->getType();
     if ($type == ArcanistDiffChangeType::TYPE_ADD) {
       $old_null = true;
     } else {
       $old_null = false;
     }
 
     if ($type == ArcanistDiffChangeType::TYPE_DELETE) {
       $new_null = true;
     } else {
       $new_null = false;
     }
 
     if ($old_null) {
       $old_data = '';
       $old_length = 0;
       $old_sha1 = str_repeat('0', 40);
     } else {
       $old_data = $this->getBlob($old_phid);
       $old_length = strlen($old_data);
       $old_sha1 = sha1("blob {$old_length}\0{$old_data}");
     }
 
     if ($new_null) {
       $new_data = '';
       $new_length = 0;
       $new_sha1 = str_repeat('0', 40);
     } else {
       $new_data = $this->getBlob($new_phid);
       $new_length = strlen($new_data);
       $new_sha1 = sha1("blob {$new_length}\0{$new_data}");
     }
 
     $content = array();
     $content[] = "index {$old_sha1}..{$new_sha1}";
     $content[] = "GIT binary patch";
 
     $content[] = "literal {$new_length}";
     $content[] = $this->emitBinaryDiffBody($new_data);
 
     $content[] = "literal {$old_length}";
     $content[] = $this->emitBinaryDiffBody($old_data);
 
     return implode("\n", $content);
   }
 
   private function emitBinaryDiffBody($data) {
     // See emit_binary_diff_body() in diff.c for git's implementation.
 
     $buf = '';
 
     $deflated = gzcompress($data);
     $lines = str_split($deflated, 52);
     foreach ($lines as $line) {
       $len = strlen($line);
       // The first character encodes the line length.
       if ($len <= 26) {
         $buf .= chr($len + ord('A') - 1);
       } else {
         $buf .= chr($len - 26 + ord('a') - 1);
       }
       $buf .= $this->encodeBase85($line);
       $buf .= "\n";
     }
 
     $buf .= "\n";
 
     return $buf;
   }
 
   private function encodeBase85($data) {
     // This is implemented awkwardly in order to closely mirror git's
     // implementation in base85.c
 
     static $map = array(
       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
       'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
       'U', 'V', 'W', 'X', 'Y', 'Z',
       'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
       'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
       'u', 'v', 'w', 'x', 'y', 'z',
       '!', '#', '$', '%', '&', '(', ')', '*', '+', '-',
       ';', '<', '=', '>', '?', '@', '^', '_', '`', '{',
       '|', '}', '~',
     );
 
     $buf = '';
 
     $pos = 0;
     $bytes = strlen($data);
     while ($bytes) {
       $accum = '0';
       for ($count = 24; $count >= 0; $count -= 8) {
         $val = ord($data[$pos++]);
         $val = bcmul($val, (string)(1 << $count));
         $accum = bcadd($accum, $val);
         if (--$bytes == 0) {
           break;
         }
       }
       $slice = '';
       for ($count = 4; $count >= 0; $count--) {
         $val = bcmod($accum, 85);
         $accum = bcdiv($accum, 85);
         $slice .= $map[$val];
       }
       $buf .= strrev($slice);
     }
 
     return $buf;
   }
 
 }
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index 2ccbed0b..21a5ffc7 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,857 +1,857 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Interfaces with Git working copies.
  *
  * @group workingcopy
  */
 final class ArcanistGitAPI extends ArcanistRepositoryAPI {
 
   private $status;
   private $relativeCommit = null;
   private $relativeExplanation = '???';
   private $repositoryHasNoCommits = false;
   const SEARCH_LENGTH_FOR_PARENT_REVISIONS = 16;
 
   /**
    * For the repository's initial commit, 'git diff HEAD^' and similar do
    * not work. Using this instead does work.
    */
   const GIT_MAGIC_ROOT_COMMIT = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 
   public static function newHookAPI($root) {
     return new ArcanistGitAPI($root);
   }
 
   protected function buildLocalFuture(array $argv) {
 
     $argv[0] = 'git '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
 
   public function getSourceControlSystemName() {
     return 'git';
   }
 
   public function getHasCommits() {
     return !$this->repositoryHasNoCommits;
   }
 
   public function setRelativeCommit($relative_commit) {
     $this->relativeCommit = $relative_commit;
     return $this;
   }
 
   public function getLocalCommitInformation() {
     if ($this->repositoryHasNoCommits) {
       // Zero commits.
       throw new Exception(
         "You can't get local commit information for a repository with no ".
         "commits.");
     } else if ($this->relativeCommit == self::GIT_MAGIC_ROOT_COMMIT) {
       // One commit.
       $against = 'HEAD';
     } else {
 
       // 2..N commits. We include commits reachable from HEAD which are
       // not reachable from the relative commit; this is consistent with
       // user expectations even though it is not actually the diff range.
       // Particularly:
       //
       //    |
       //    D <----- master branch
       //    |
       //    C  Y <- feature branch
       //    | /|
       //    B  X
       //    | /
       //    A
       //    |
       //
       // If "A, B, C, D" are master, and the user is at Y, when they run
       // "arc diff B" they want (and get) a diff of B vs Y, but they think about
       // this as being the commits X and Y. If we log "B..Y", we only show
       // Y. With "Y --not B", we show X and Y.
 
       $against = csprintf('%s --not %s', 'HEAD', $this->getRelativeCommit());
     }
 
     // NOTE: Windows escaping of "%" symbols apparently is inherently broken;
     // when passed throuhgh escapeshellarg() they are replaced with spaces.
 
     // TODO: Learn how cmd.exe works and find some clever workaround?
 
     // NOTE: If we use "%x00", output is truncated in Windows.
 
     list($info) = $this->execxLocal(
       phutil_is_windows()
         ? 'log %C --format=%C --'
         : 'log %C --format=%s --',
       $against,
       // NOTE: "%B" is somewhat new, use "%s%n%n%b" instead.
       '%H%x01%T%x01%P%x01%at%x01%an%x01%s%x01%s%n%n%b%x02');
 
     $commits = array();
 
     $info = trim($info, " \n\2");
     if (!strlen($info)) {
       return array();
     }
 
     $info = explode("\2", $info);
     foreach ($info as $line) {
       list($commit, $tree, $parents, $time, $author, $title, $message)
         = explode("\1", trim($line), 7);
       $message = rtrim($message);
 
       $commits[$commit] = array(
         'commit'  => $commit,
         'tree'    => $tree,
         'parents' => array_filter(explode(' ', $parents)),
         'time'    => $time,
         'author'  => $author,
         'summary' => $title,
         'message' => $message,
       );
     }
 
     return $commits;
   }
 
   public function getRelativeCommit() {
     if ($this->relativeCommit === null) {
 
       // Detect zero-commit or one-commit repositories. There is only one
       // relative-commit value that makes any sense in these repositories: the
       // empty tree.
       list($err) = $this->execManualLocal('rev-parse --verify HEAD^');
       if ($err) {
         list($err) = $this->execManualLocal('rev-parse --verify HEAD');
         if ($err) {
           $this->repositoryHasNoCommits = true;
         }
 
         $this->relativeCommit = self::GIT_MAGIC_ROOT_COMMIT;
 
         if ($this->repositoryHasNoCommits) {
           $this->relativeExplanation = "the repository has no commits.";
         } else {
           $this->relativeExplanation = "the repository has only one commit.";
         }
 
         return $this->relativeCommit;
       }
 
       $do_write = false;
       $default_relative = null;
       $working_copy = $this->getWorkingCopyIdentity();
       if ($working_copy) {
         $default_relative = $working_copy->getConfig(
           'git.default-relative-commit');
         $this->relativeExplanation =
           "it is the merge-base of '{$default_relative}' and HEAD, as ".
           "specified in 'git.default-relative-commit' in '.arcconfig'. This ".
           "setting overrides other settings.";
       }
 
       if (!$default_relative) {
         list($err, $upstream) = $this->execManualLocal(
           "rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");
 
         if (!$err) {
           $default_relative = trim($upstream);
           $this->relativeExplanation =
             "it is the merge-base of '{$default_relative}' (the Git upstream ".
             "of the current branch) HEAD.";
         }
       }
 
       if (!$default_relative) {
         $default_relative = $this->readScratchFile('default-relative-commit');
         $default_relative = trim($default_relative);
         if ($default_relative) {
           $this->relativeExplanation =
             "it is the merge-base of '{$default_relative}' and HEAD, as ".
             "specified in '.arc/default-relative-commit'.";
         }
       }
 
       if (!$default_relative) {
 
         // TODO: Remove the history lesson soon.
 
         echo phutil_console_format(
           "<bg:green>** Select a Default Commit Range **</bg>\n\n");
         echo phutil_console_wrap(
           "You're running a command which operates on a range of revisions ".
           "(usually, from some revision to HEAD) but have not specified the ".
           "revision that should determine the start of the range.\n\n".
           "Previously, arc assumed you meant 'HEAD^' when you did not specify ".
           "a start revision, but this behavior does not make much sense in ".
           "most workflows outside of Facebook's historic git-svn workflow.\n\n".
           "arc no longer assumes 'HEAD^'. You must specify a relative commit ".
           "explicitly when you invoke a command (e.g., `arc diff HEAD^`, not ".
           "just `arc diff`) or select a default for this working copy.\n\n".
           "In most cases, the best default is 'origin/master'. You can also ".
           "select 'HEAD^' to preserve the old behavior, or some other remote ".
           "or branch. But you almost certainly want to select ".
           "'origin/master'.\n\n".
           "(Technically: the merge-base of the selected revision and HEAD is ".
           "used to determine the start of the commit range.)");
 
         $prompt = "What default do you want to use? [origin/master]";
         $default = phutil_console_prompt($prompt);
 
         if (!strlen(trim($default))) {
           $default = 'origin/master';
         }
 
         $default_relative = $default;
         $do_write = true;
       }
 
       list($object_type) = $this->execxLocal(
         'cat-file -t %s',
         $default_relative);
 
       if (trim($object_type) !== 'commit') {
         throw new Exception(
-          "Relative commit '{$relative}' is not the name of a commit!");
+          "Relative commit '{$default_relative}' is not the name of a commit!");
       }
 
       if ($do_write) {
         // Don't perform this write until we've verified that the object is a
         // valid commit name.
         $this->writeScratchFile('default-relative-commit', $default_relative);
         $this->relativeExplanation =
           "it is the merge-base of '{$default_relative}' and HEAD, as you ".
           "just specified.";
       }
 
       list($merge_base) = $this->execxLocal(
         'merge-base %s HEAD',
         $default_relative);
 
       $this->relativeCommit = trim($merge_base);
     }
 
     return $this->relativeCommit;
   }
 
   private function getDiffFullOptions($detect_moves_and_renames = true) {
     $options = array(
       self::getDiffBaseOptions(),
       '--no-color',
       '--src-prefix=a/',
       '--dst-prefix=b/',
       '-U'.$this->getDiffLinesOfContext(),
     );
 
     if ($detect_moves_and_renames) {
       $options[] = '-M';
       $options[] = '-C';
     }
 
     return implode(' ', $options);
   }
 
   private function getDiffBaseOptions() {
     $options = array(
       // Disable external diff drivers, like graphical differs, since Arcanist
       // needs to capture the diff text.
       '--no-ext-diff',
       // Disable textconv so we treat binary files as binary, even if they have
       // an alternative textual representation. TODO: Ideally, Differential
       // would ship up the binaries for 'arc patch' but display the textconv
       // output in the visual diff.
       '--no-textconv',
     );
     return implode(' ', $options);
   }
 
   public function getFullGitDiff() {
     $options = $this->getDiffFullOptions();
     list($stdout) = $this->execxLocal(
       "diff {$options} %s --",
       $this->getRelativeCommit());
     return $stdout;
   }
 
   /**
    * @param string Path to generate a diff for.
    * @param bool   If true, detect moves and renames. Otherwise, ignore
    *               moves/renames; this is useful because it prompts git to
    *               generate real diff text.
    */
   public function getRawDiffText($path, $detect_moves_and_renames = true) {
     $options = $this->getDiffFullOptions($detect_moves_and_renames);
     list($stdout) = $this->execxLocal(
       "diff {$options} %s -- %s",
       $this->getRelativeCommit(),
       $path);
     return $stdout;
   }
 
   public function getBranchName() {
     // TODO: consider:
     //
     //    $ git rev-parse --abbrev-ref `git symbolic-ref HEAD`
     //
     // But that may fail if you're not on a branch.
     list($stdout) = $this->execxLocal('branch');
 
     $matches = null;
     if (preg_match('/^\* (.+)$/m', $stdout, $matches)) {
       return $matches[1];
     }
     return null;
   }
 
   public function getSourceControlPath() {
     // TODO: Try to get something useful here.
     return null;
   }
 
   public function getGitCommitLog() {
     $relative = $this->getRelativeCommit();
     if ($this->repositoryHasNoCommits) {
       // No commits yet.
       return '';
     } else if ($relative == self::GIT_MAGIC_ROOT_COMMIT) {
       // First commit.
       list($stdout) = $this->execxLocal(
         'log --format=medium HEAD');
     } else {
       // 2..N commits.
       list($stdout) = $this->execxLocal(
         'log --first-parent --format=medium %s..HEAD',
         $this->getRelativeCommit());
     }
     return $stdout;
   }
 
   public function getGitHistoryLog() {
     list($stdout) = $this->execxLocal(
       'log --format=medium -n%d %s',
       self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
       $this->getRelativeCommit());
     return $stdout;
   }
 
   public function getSourceControlBaseRevision() {
     list($stdout) = $this->execxLocal(
       'rev-parse %s',
       $this->getRelativeCommit());
     return rtrim($stdout, "\n");
   }
 
   public function getCanonicalRevisionName($string) {
     list($stdout) = $this->execxLocal('show -s --format=%C %s',
       '%H', $string);
     return rtrim($stdout);
   }
 
   public function getWorkingCopyStatus() {
     if (!isset($this->status)) {
 
       $options = $this->getDiffBaseOptions();
 
       // -- parallelize these slow cpu bound git calls.
 
       // Find committed changes.
       $committed_future = $this->buildLocalFuture(
         array(
           "diff {$options} --raw %s --",
           $this->getRelativeCommit(),
         ));
 
       // Find uncommitted changes.
       $uncommitted_future = $this->buildLocalFuture(
         array(
           "diff {$options} --raw %s --",
           $this->repositoryHasNoCommits
             ? self::GIT_MAGIC_ROOT_COMMIT
             : 'HEAD',
         ));
 
       // Untracked files
       $untracked_future = $this->buildLocalFuture(
         array(
           'ls-files --others --exclude-standard',
         ));
 
       // TODO: This doesn't list unstaged adds. It's not clear how to get that
       // list other than "git status --porcelain" and then parsing it. :/
 
       // Unstaged changes
       $unstaged_future = $this->buildLocalFuture(
         array(
           'ls-files -m',
         ));
 
       $futures = array(
         $committed_future,
         $uncommitted_future,
         $untracked_future,
         $unstaged_future
       );
       Futures($futures)->resolveAll();
 
 
       // -- read back and process the results
 
       list($stdout, $stderr) = $committed_future->resolvex();
       $files = $this->parseGitStatus($stdout);
 
       list($stdout, $stderr) = $uncommitted_future->resolvex();
       $uncommitted_files = $this->parseGitStatus($stdout);
       foreach ($uncommitted_files as $path => $mask) {
         $mask |= self::FLAG_UNCOMMITTED;
         if (!isset($files[$path])) {
           $files[$path] = 0;
         }
         $files[$path] |= $mask;
       }
 
       list($stdout, $stderr) = $untracked_future->resolvex();
       $stdout = rtrim($stdout, "\n");
       if (strlen($stdout)) {
         $stdout = explode("\n", $stdout);
         foreach ($stdout as $file) {
           $files[$file] = self::FLAG_UNTRACKED;
         }
       }
 
       list($stdout, $stderr) = $unstaged_future->resolvex();
       $stdout = rtrim($stdout, "\n");
       if (strlen($stdout)) {
         $stdout = explode("\n", $stdout);
         foreach ($stdout as $file) {
           $files[$file] = isset($files[$file])
             ? ($files[$file] | self::FLAG_UNSTAGED)
             : self::FLAG_UNSTAGED;
         }
       }
 
       $this->status = $files;
     }
 
     return $this->status;
   }
 
   public function amendCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
     $this->execxLocal(
       'commit --amend --allow-empty -F %s',
       $tmp_file);
   }
 
   public function getPreReceiveHookStatus($old_ref, $new_ref) {
     $options = $this->getDiffBaseOptions();
     list($stdout) = $this->execxLocal(
       "diff {$options} --raw %s %s --",
       $old_ref,
       $new_ref);
     return $this->parseGitStatus($stdout, $full = true);
   }
 
   private function parseGitStatus($status, $full = false) {
     static $flags = array(
       'A' => self::FLAG_ADDED,
       'M' => self::FLAG_MODIFIED,
       'D' => self::FLAG_DELETED,
     );
 
     $status = trim($status);
     $lines = array();
     foreach (explode("\n", $status) as $line) {
       if ($line) {
         $lines[] = preg_split("/[ \t]/", $line);
       }
     }
 
     $files = array();
     foreach ($lines as $line) {
       $mask = 0;
       $flag = $line[4];
       $file = $line[5];
       foreach ($flags as $key => $bits) {
         if ($flag == $key) {
           $mask |= $bits;
         }
       }
       if ($full) {
         $files[$file] = array(
           'mask' => $mask,
           'ref'  => rtrim($line[3], '.'),
         );
       } else {
         $files[$file] = $mask;
       }
     }
 
     return $files;
   }
 
   public function getBlame($path) {
     // TODO: 'git blame' supports --porcelain and we should probably use it.
     list($stdout) = $this->execxLocal(
       'blame --date=iso -w -M %s -- %s',
       $this->getRelativeCommit(),
       $path);
 
     $blame = array();
     foreach (explode("\n", trim($stdout)) as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       // lines predating a git repo's history are blamed to the oldest revision,
       // with the commit hash prepended by a ^. we shouldn't count these lines
       // as blaming to the oldest diff's unfortunate author
       if ($line[0] == '^') {
         continue;
       }
 
       $matches = null;
       $ok = preg_match(
         '/^([0-9a-f]+)[^(]+?[(](.*?) +\d\d\d\d-\d\d-\d\d/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception("Bad blame? `{$line}'");
       }
       $revision = $matches[1];
       $author = $matches[2];
 
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getRelativeCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision($path, 'HEAD');
   }
 
   private function parseGitTree($stdout) {
     $result = array();
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       return $result;
     }
 
     $lines = explode("\n", $stdout);
     foreach ($lines as $line) {
       $matches = array();
       $ok = preg_match(
         '/^(\d{6}) (blob|tree) ([a-z0-9]{40})[\t](.*)$/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception("Failed to parse git ls-tree output!");
       }
       $result[$matches[4]] = array(
         'mode' => $matches[1],
         'type' => $matches[2],
         'ref'  => $matches[3],
       );
     }
     return $result;
   }
 
   private function getFileDataAtRevision($path, $revision) {
 
     // NOTE: We don't want to just "git show {$revision}:{$path}" since if the
     // path was a directory at the given revision we'll get a list of its files
     // and treat it as though it as a file containing a list of other files,
     // which is silly.
 
     list($stdout) = $this->execxLocal(
       'ls-tree %s -- %s',
       $revision,
       $path);
 
     $info = $this->parseGitTree($stdout);
     if (empty($info[$path])) {
       // No such path, or the path is a directory and we executed 'ls-tree dir/'
       // and got a list of its contents back.
       return null;
     }
 
     if ($info[$path]['type'] != 'blob') {
       // Path is or was a directory, not a file.
       return null;
     }
 
     list($stdout) = $this->execxLocal(
       'cat-file blob %s',
        $info[$path]['ref']);
     return $stdout;
   }
 
   /**
    * Returns names of all the branches in the current repository.
    *
    * @return array where each element is a triple ('name', 'sha1', 'current')
    */
   public function getAllBranches() {
     list($branch_info) = $this->execxLocal('branch --no-color');
     $lines = explode("\n", trim($branch_info));
     $result = array();
     foreach ($lines as $line) {
       $match = array();
       preg_match('/^(\*?)\s*(.*)$/', $line, $match);
       $name = $match[2];
       if ($name == '(no branch)') {
         // Just ignore this, we could theoretically try to figure out the ref
         // and treat it like a real branch but that's sort of ridiculous.
         continue;
       }
       $result[] = array(
         'current' => !empty($match[1]),
         'name'    => $name,
       );
     }
     $all_names = ipull($result, 'name');
     // Calling 'git branch' first and then 'git rev-parse' is way faster than
     // 'git branch -v' for some reason.
     list($sha1s_string) = $this->execxLocal('rev-parse %Ls', $all_names);
 
     $sha1_map = array_combine($all_names, explode("\n", trim($sha1s_string)));
     foreach ($result as &$branch) {
       $branch['sha1'] = $sha1_map[$branch['name']];
     }
     return $result;
   }
 
   /**
    * Returns git commit messages for the given revisions,
    * in the specified format (see git show --help for options).
    *
    * @param array $revs a list of commit hashes
    * @param string $format the format to show messages in
    */
   public function multigetCommitMessages($revs, $format) {
 
     list($commits_string) = $this->execxLocal(
       "show -s --pretty='format:'%s%s %Ls",
       $format,
       '%x00',
       $revs);
 
     $commits_list = array_slice(explode("\0", $commits_string), 0, -1);
     $commits_list = array_combine($revs, $commits_list);
     return $commits_list;
   }
 
   public function getRepositoryOwner() {
     list($owner) = $this->execxLocal('config --get user.name');
     return trim($owner);
   }
 
   public function getWorkingCopyRevision() {
     list($stdout) = $this->execxLocal('rev-parse HEAD');
     return rtrim($stdout, "\n");
   }
 
   public function isHistoryDefaultImmutable() {
     return false;
   }
 
   public function supportsAmend() {
     return true;
   }
 
   public function supportsRelativeLocalCommits() {
     return true;
   }
 
   public function hasLocalCommit($commit) {
     try {
       $this->getCanonicalRevisionName($commit);
     } catch (CommandException $exception) {
       return false;
     }
     return true;
   }
 
   public function parseRelativeLocalCommit(array $argv) {
     if (count($argv) == 0) {
       return;
     }
     if (count($argv) != 1) {
       throw new ArcanistUsageException("Specify only one commit.");
     }
     $base = reset($argv);
     if ($base == ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
       $merge_base = $base;
       $this->relativeExplanation =
         "you explicitly specified the empty tree.";
     } else {
       list($err, $merge_base) = $this->execManualLocal(
         'merge-base %s HEAD',
         $base);
       if ($err) {
         throw new ArcanistUsageException(
           "Unable to find any git commit named '{$base}' in this repository.");
       }
       $this->relativeExplanation =
         "it is the merge-base of '{$base}' and HEAD, as you explicitly ".
         "specified.";
     }
     $this->setRelativeCommit(trim($merge_base));
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullGitDiff();
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if (!$branch) {
       throw new ArcanistUsageException(
         "Under git, you must specify the branch you want to merge.");
     }
     $err = phutil_passthru(
       '(cd %s && git merge --no-ff -m %s %s)',
       $this->getPath(),
       $message,
       $branch);
 
     if ($err) {
       throw new ArcanistUsageException("Merge failed!");
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return "You may now push this commit upstream, as appropriate (e.g. with ".
            "'git push', or 'git svn dcommit', or by printing and faxing it).";
   }
 
   public function getCommitMessageForRevision($rev) {
     list($message) = $this->execxLocal(
       'log -n1 %s',
       $rev);
     $parser = new ArcanistDiffParser();
     return head($parser->parseDiff($message));
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getGitCommitLog();
     if (!strlen($messages)) {
       return array();
     }
 
     $parser = new ArcanistDiffParser();
     $messages = $parser->parseDiff($messages);
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
         $message->getMetadata('message'));
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $message->getCommitHash();
       }
     }
 
     if ($revision_ids) {
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'ids' => $revision_ids,
         ));
 
       foreach ($results as $key => $result) {
         $hash = substr($reason_map[$result['id']], 0, 16);
         $results[$key]['why'] =
           "Commit message for '{$hash}' has explicit 'Differential Revision'.";
       }
 
       return $results;
     }
 
     // If we didn't succeed, try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('gtcm', $commit['commit']);
       $hashes[] = array('gttr', $commit['tree']);
     }
 
     $results = $conduit->callMethodSynchronous(
       'differential.query',
       $query + array(
         'commitHashes' => $hashes,
       ));
 
     foreach ($results as $key => $result) {
       $results[$key]['why'] =
         "A git commit or tree hash in the commit range is already attached ".
         "to the Differential revision.";
     }
 
     return $results;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('pull');
   }
 
   public function getRelativeExplanation() {
     return $this->relativeExplanation;
   }
 
   public function getCommitSummary($commit) {
     if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
       return '(The Empty Tree)';
     }
 
     list($summary) = $this->execxLocal(
       'log -n 1 --format=%C %s',
       '%s',
       $commit);
 
     return trim($summary);
   }
 
 }
diff --git a/src/workflow/ArcanistPatchWorkflow.php b/src/workflow/ArcanistPatchWorkflow.php
index 30e7b1b1..771dfb22 100644
--- a/src/workflow/ArcanistPatchWorkflow.php
+++ b/src/workflow/ArcanistPatchWorkflow.php
@@ -1,823 +1,823 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Applies changes from Differential or a file to the working copy.
  *
  * @group workflow
  */
 final class ArcanistPatchWorkflow extends ArcanistBaseWorkflow {
 
   const SOURCE_BUNDLE         = 'bundle';
   const SOURCE_PATCH          = 'patch';
   const SOURCE_REVISION       = 'revision';
   const SOURCE_DIFF           = 'diff';
 
   private $source;
   private $sourceParam;
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **patch** __D12345__
       **patch** __--revision__ __revision_id__
       **patch** __--diff__ __diff_id__
       **patch** __--patch__ __file__
       **patch** __--arcbundle__ __bundlefile__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Apply the changes in a Differential revision, patchfile, or arc
           bundle to the working copy.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'revision' => array(
         'param' => 'revision_id',
         'paramtype' => 'complete',
         'help' =>
           "Apply changes from a Differential revision, using the most recent ".
           "diff that has been attached to it. You can run 'arc patch D12345' ".
           "as a shorthand for this.",
       ),
       'diff' => array(
         'param' => 'diff_id',
         'help' =>
           "Apply changes from a Differential diff. Normally you want to use ".
           "--revision to get the most recent changes, but you can ".
           "specifically apply an out-of-date diff or a diff which was never ".
           "attached to a revision by using this flag.",
       ),
       'arcbundle' => array(
         'param' => 'bundlefile',
         'paramtype' => 'file',
         'help' =>
           "Apply changes from an arc bundle generated with 'arc export'.",
       ),
       'patch' => array(
         'param' => 'patchfile',
         'paramtype' => 'file',
         'help' =>
           "Apply changes from a git patchfile or unified patchfile.",
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           "Attempt to convert non UTF-8 patch into specified encoding.",
       ),
       'update' => array(
         'supports' => array(
           'git', 'svn', 'hg'
         ),
         'help' =>
           "Update the local working copy before applying the patch.",
         'conflicts' => array(
           'nobranch' => true,
         ),
       ),
       'nocommit' => array(
         'supports' => array(
           'git'
         ),
         'help' =>
           "Normally under git if the patch is successful the changes are ".
           "committed to the working copy. This flag prevents the commit.",
       ),
       'nobranch' => array(
         'supports' => array(
           'git'
         ),
         'help' =>
           "Normally under git a new branch is created and then the patch ".
           "is applied and committed in the branch.  This flag skips the ".
           "branch creation step and applies and commits the patch to the ".
           "current branch.",
         'conflicts' => array(
           'update' => true,
         ),
       ),
       'force' => array(
         'help' =>
           "Do not run any sanity checks.",
       ),
       '*' => 'name',
     );
   }
 
   protected function didParseArguments() {
     $source = null;
     $requested = 0;
     if ($this->getArgument('revision')) {
       $source = self::SOURCE_REVISION;
       $requested++;
     }
     if ($this->getArgument('diff')) {
       $source = self::SOURCE_DIFF;
       $requested++;
     }
     if ($this->getArgument('arcbundle')) {
       $source = self::SOURCE_BUNDLE;
       $requested++;
     }
     if ($this->getArgument('patch')) {
       $source = self::SOURCE_PATCH;
       $requested++;
     }
 
     $use_revision_id = null;
     if ($this->getArgument('name')) {
       $namev = $this->getArgument('name');
       if (count($namev) > 1) {
         throw new ArcanistUsageException("Specify at most one revision name.");
       }
       $source = self::SOURCE_REVISION;
       $requested++;
 
       $use_revision_id = $this->normalizeRevisionID(head($namev));
     }
 
     if ($requested === 0) {
       throw new ArcanistUsageException(
         "Specify one of 'D12345', '--revision <revision_id>' (to select the ".
         "current changes attached to a Differential revision), ".
         "'--diff <diff_id>' (to select a specific, out-of-date diff or a ".
         "diff which is not attached to a revision), '--arcbundle <file>' ".
         "or '--patch <file>' to choose a patch source.");
     } else if ($requested > 1) {
       throw new ArcanistUsageException(
         "Options 'D12345', '--revision', '--diff', '--arcbundle' and ".
         "'--patch' are not compatible. Choose exactly one patch source.");
     }
 
     $this->source = $source;
     $this->sourceParam = nonempty(
       $use_revision_id,
       $this->getArgument($source));
   }
 
   public function requiresConduit() {
     return ($this->getSource() != self::SOURCE_PATCH);
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   private function getSource() {
     return $this->source;
   }
 
   private function getSourceParam() {
     return $this->sourceParam;
   }
 
   private function shouldCommit() {
     $no_commit = $this->getArgument('nocommit', false);
     if ($no_commit) {
       return false;
     }
 
     return true;
   }
 
   private function shouldBranch() {
     // git only for now
     $repository_api = $this->getRepositoryAPI();
     if (!($repository_api instanceof ArcanistGitAPI)) {
       return false;
     }
 
     $no_branch = $this->getArgument('nobranch', false);
     if ($no_branch) {
       return false;
     }
 
     return true;
   }
 
   private function getBranchName(ArcanistBundle $bundle) {
     $branch_name    = null;
     $repository_api = $this->getRepositoryAPI();
     $revision_id    = $bundle->getRevisionID();
     $base_name      = "arcpatch";
     if ($revision_id) {
       $base_name .= "-D{$revision_id}";
     }
 
     $suffixes = array(null, '-1', '-2', '-3');
     foreach ($suffixes as $suffix) {
       $proposed_name = $base_name.$suffix;
 
       list($err) = $repository_api->execManualLocal(
         'rev-parse --verify %s',
         $proposed_name);
 
       // no error means git rev-parse found a branch
       if (!$err) {
         echo phutil_console_format(
           "Branch name {$proposed_name} already exists; trying a new name.\n"
         );
         continue;
       } else {
         $branch_name = $proposed_name;
         break;
       }
     }
 
     if (!$branch_name) {
       throw new Exception(
         "Arc was unable to automagically make a name for this patch.  ".
         "Please clean up your working copy and try again."
       );
     }
 
     return $branch_name;
   }
 
   private function createBranch(ArcanistBundle $bundle) {
     $branch_name    = $this->getBranchName($bundle);
     $repository_api = $this->getRepositoryAPI();
     $base_revision  = $bundle->getBaseRevision();
 
     // verify the base revision is valid
     // in a working copy that uses the git-svn bridge, the base revision might
     // be a svn uri instead of a git ref
 
     // NOTE: Use 'cat-file', not 'rev-parse --verify', because 'rev-parse'
     // always "verifies" any properly-formatted commit even if it does not
     // exist.
     list($err) = $repository_api->execManualLocal(
       'cat-file -t %s',
       $base_revision);
 
     if ($base_revision && !$err) {
       $repository_api->execxLocal(
         'checkout -b %s %s',
         $branch_name,
         $base_revision);
     } else {
       $repository_api->execxLocal(
         'checkout -b %s',
         $branch_name);
     }
 
     echo phutil_console_format(
       "Created and checked out branch %s.\n",
       $branch_name);
   }
 
   private function shouldUpdateWorkingCopy() {
     return $this->getArgument('update', false);
   }
 
   private function updateWorkingCopy() {
     echo "Updating working copy...\n";
     $this->getRepositoryAPI()->updateWorkingCopy();
     echo "Done.\n";
   }
 
   public function run() {
 
     $source = $this->getSource();
     $param = $this->getSourceParam();
     try {
       switch ($source) {
         case self::SOURCE_PATCH:
           if ($param == '-') {
             $patch = @file_get_contents('php://stdin');
             if (!strlen($patch)) {
               throw new ArcanistUsageException(
                 "Failed to read patch from stdin!");
             }
           } else {
             $patch = Filesystem::readFile($param);
           }
           $bundle = ArcanistBundle::newFromDiff($patch);
           break;
         case self::SOURCE_BUNDLE:
           $path = $this->getArgument('arcbundle');
           $bundle = ArcanistBundle::newFromArcBundle($path);
           break;
         case self::SOURCE_REVISION:
           $bundle = $this->loadRevisionBundleFromConduit(
             $this->getConduit(),
             $param);
           break;
         case self::SOURCE_DIFF:
           $bundle = $this->loadDiffBundleFromConduit(
             $this->getConduit(),
             $param);
           break;
       }
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-INVALID-SESSION') {
         // Phabricator is not configured to allow anonymous access to
         // Differential.
         $this->authenticateConduit();
         return $this->run();
       } else {
         throw $ex;
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
     if (!$try_encoding) {
       if ($this->requiresConduit()) {
         try {
           $try_encoding = $this->getRepositoryEncoding();
         } catch (ConduitClientException $e) {
           $try_encoding = null;
         }
       }
     }
 
     if ($try_encoding) {
       $bundle->setEncoding($try_encoding);
     }
 
     $force = $this->getArgument('force', false);
     if ($force) {
       // force means don't do any sanity checks about the patch
     } else {
       $this->sanityCheck($bundle);
     }
 
     // we should update the working copy before we do ANYTHING else
     if ($this->shouldUpdateWorkingCopy()) {
       $this->updateWorkingCopy();
     }
 
     if ($this->shouldBranch()) {
       $this->createBranch($bundle);
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $patch_err = 0;
 
       $copies = array();
       $deletes = array();
       $patches = array();
       $propset = array();
       $adds = array();
       $symlinks = array();
 
       $changes = $bundle->getChanges();
       foreach ($changes as $change) {
         $type = $change->getType();
         $should_patch = true;
 
         $filetype = $change->getFileType();
         switch ($filetype) {
           case ArcanistDiffChangeType::FILE_SYMLINK:
             $should_patch = false;
             $symlinks[] = $change;
             break;
         }
 
         switch ($type) {
           case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
           case ArcanistDiffChangeType::TYPE_MULTICOPY:
           case ArcanistDiffChangeType::TYPE_DELETE:
             $path = $change->getCurrentPath();
             $fpath = $repository_api->getPath($path);
             if (!@file_exists($fpath)) {
               $ok = phutil_console_confirm(
                 "Patch deletes file '{$path}', but the file does not exist in ".
                 "the working copy. Continue anyway?");
               if (!$ok) {
                 throw new ArcanistUserAbortException();
               }
             } else {
               $deletes[] = $change->getCurrentPath();
             }
             $should_patch = false;
             break;
           case ArcanistDiffChangeType::TYPE_COPY_HERE:
           case ArcanistDiffChangeType::TYPE_MOVE_HERE:
             $path = $change->getOldPath();
             $fpath = $repository_api->getPath($path);
             if (!@file_exists($fpath)) {
               $cpath = $change->getCurrentPath();
               if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
                 $verbs = 'copies';
               } else {
                 $verbs = 'moves';
               }
               $ok = phutil_console_confirm(
                 "Patch {$verbs} '{$path}' to '{$cpath}', but source path ".
                 "does not exist in the working copy. Continue anyway?");
               if (!$ok) {
                 throw new ArcanistUserAbortException();
               }
             } else {
               $copies[] = array(
                 $change->getOldPath(),
                 $change->getCurrentPath());
             }
             break;
           case ArcanistDiffChangeType::TYPE_ADD:
             $adds[] = $change->getCurrentPath();
             break;
         }
         if ($should_patch) {
           if ($change->getHunks()) {
             $cbundle = ArcanistBundle::newFromChanges(array($change));
             $patches[$change->getCurrentPath()] = $cbundle->toUnifiedDiff();
           }
           $prop_old = $change->getOldProperties();
           $prop_new = $change->getNewProperties();
           $props = $prop_old + $prop_new;
           foreach ($props as $key => $ignored) {
             if (idx($prop_old, $key) !== idx($prop_new, $key)) {
               $propset[$change->getCurrentPath()][$key] = idx($prop_new, $key);
             }
           }
         }
       }
 
       // Before we start doing anything, create all the directories we're going
       // to add files to if they don't already exist.
       foreach ($copies as $copy) {
         list($src, $dst) = $copy;
         $this->createParentDirectoryOf($dst);
       }
 
       foreach ($patches as $path => $patch) {
         $this->createParentDirectoryOf($path);
       }
 
       foreach ($adds as $add) {
         $this->createParentDirectoryOf($add);
       }
 
       // TODO: The SVN patch workflow likely does not work on windows because
       // of the (cd ...) stuff.
 
       foreach ($copies as $copy) {
         list($src, $dst) = $copy;
         passthru(
           csprintf(
             '(cd %s; svn cp %s %s)',
             $repository_api->getPath(),
             $src,
             $dst));
       }
 
       foreach ($deletes as $delete) {
         passthru(
           csprintf(
             '(cd %s; svn rm %s)',
             $repository_api->getPath(),
             $delete));
       }
 
       foreach ($symlinks as $symlink) {
         $link_target = $symlink->getSymlinkTarget();
         $link_path = $symlink->getCurrentPath();
         switch ($symlink->getType()) {
           case ArcanistDiffChangeType::TYPE_ADD:
-          case ArcanistDiffChangeType::TYPE_MODIFY:
+          case ArcanistDiffChangeType::TYPE_CHANGE:
           case ArcanistDiffChangeType::TYPE_MOVE_HERE:
           case ArcanistDiffChangeType::TYPE_COPY_HERE:
             execx(
               '(cd %s && ln -sf %s %s)',
               $repository_api->getPath(),
               $link_target,
               $link_path);
             break;
         }
       }
 
       foreach ($patches as $path => $patch) {
         $tmp = new TempFile();
         Filesystem::writeFile($tmp, $patch);
         $err = null;
         passthru(
           csprintf(
             '(cd %s; patch -p0 < %s)',
             $repository_api->getPath(),
             $tmp),
           $err);
         if ($err) {
           $patch_err = max($patch_err, $err);
         }
       }
 
       foreach ($adds as $add) {
         passthru(
           csprintf(
             '(cd %s; svn add %s)',
             $repository_api->getPath(),
             $add));
       }
 
       foreach ($propset as $path => $changes) {
         foreach ($change as $prop => $value) {
           // TODO: Probably need to handle svn:executable specially here by
           // doing chmod +x or -x.
           if ($value === null) {
             passthru(
               csprintf(
                 '(cd %s; svn propdel %s %s)',
                 $repository_api->getPath(),
                 $prop,
                 $path));
           } else {
             passthru(
               csprintf(
                 '(cd %s; svn propset %s %s %s)',
                 $repository_api->getPath(),
                 $prop,
                 $value,
                 $path));
           }
         }
       }
 
       if ($patch_err == 0) {
         echo phutil_console_format(
           "<bg:green>** OKAY **</bg> Successfully applied patch ".
           "to the working copy.\n");
       } else {
         echo phutil_console_format(
           "\n\n<bg:yellow>** WARNING **</bg> Some hunks could not be applied ".
           "cleanly by the unix 'patch' utility. Your working copy may be ".
           "different from the revision's base, or you may be in the wrong ".
           "subdirectory. You can export the raw patch file using ".
           "'arc export --unified', and then try to apply it by fiddling with ".
           "options to 'patch' (particularly, -p), or manually. The output ".
           "above, from 'patch', may be helpful in figuring out what went ".
           "wrong.\n");
       }
 
       return $patch_err;
     } else if ($repository_api instanceof ArcanistGitAPI) {
       $future = $repository_api->execFutureLocal(
         'apply --index --reject');
       $future->write($bundle->toGitPatch());
 
       try {
         $future->resolvex();
       } catch (CommandException $ex) {
         echo phutil_console_format(
           "\n<bg:red>** Patch Failed! **</bg>\n");
         $stderr = $ex->getStdErr();
         if (preg_match('/already exists in working directory/', $stderr)) {
           echo phutil_console_wrap(
             phutil_console_format(
               "\n<bg:yellow>** WARNING **</bg> This patch may have failed ".
               "because it attempts to change the case of a filename (for ".
               "instance, from 'example.c' to 'Example.c'). Git can not apply ".
               "patches like this on case-insensitive filesystems. You must ".
               "apply this patch manually.\n"));
         }
         throw $ex;
       }
 
       if ($this->shouldCommit()) {
         $commit_message = $this->getCommitMessage($bundle);
         $future = $repository_api->execFutureLocal(
           'commit -a -F -');
         $future->write($commit_message);
         $future->resolvex();
         $verb = 'committed';
       } else {
         $verb = 'applied';
       }
       echo phutil_console_format(
         "<bg:green>** OKAY **</bg> Successfully {$verb} patch.\n");
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $future = $repository_api->execFutureLocal(
         'import --no-commit -');
       $future->write($bundle->toGitPatch());
       $future->resolvex();
 
       echo phutil_console_format(
         "<bg:green>** OKAY **</bg> Successfully applied patch.\n");
     } else {
       throw new Exception('Unknown version control system.');
     }
 
     return 0;
   }
 
   private function getCommitMessage(ArcanistBundle $bundle) {
     $revision_id    = $bundle->getRevisionID();
     $commit_message = null;
     $prompt_message = null;
 
     // if we have a revision id the commit message is in differential
 
     // TODO: See T848 for the authenticated stuff.
     if ($revision_id && $this->isConduitAuthenticated()) {
 
       $conduit        = $this->getConduit();
       $commit_message = $conduit->callMethodSynchronous(
         'differential.getcommitmessage',
         array(
           'revision_id' => $revision_id,
         ));
       $prompt_message = "  Note arcanist failed to load the commit message ".
                         "from differential for revision D{$revision_id}.";
     }
 
     // no revision id or failed to fetch commit message so get it from the
     // user on the command line
     if (!$commit_message) {
       $template =
         "\n\n".
         "# Enter a commit message for this patch.  If you just want to apply ".
         "the patch to the working copy without committing, re-run arc patch ".
         "with the --nocommit flag.".
         $prompt_message.
         "\n";
 
       $commit_message = id(new PhutilInteractiveEditor($template))
         ->setName('arcanist-patch-commit-message')
         ->editInteractively();
 
       $commit_message = ArcanistCommentRemover::removeComments($commit_message);
       if (!strlen(trim($commit_message))) {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $commit_message;
   }
 
   public function getShellCompletions(array $argv) {
     // TODO: Pull open diffs from 'arc list'?
     return array('ARGUMENT');
   }
 
   /**
    * Do the best we can to prevent PEBKAC and id10t issues.
    */
   private function sanityCheck(ArcanistBundle $bundle) {
 
     // Require clean working copy
     $this->requireCleanWorkingCopy();
 
     // Check to see if the bundle's project id matches the working copy
     // project id
     $bundle_project_id = $bundle->getProjectID();
     $working_copy_project_id = $this->getWorkingCopy()->getProjectID();
     if (empty($bundle_project_id)) {
       // this means $source is SOURCE_PATCH || SOURCE_BUNDLE w/ $version = 0
       // they don't come with a project id so just do nothing
     } else if ($bundle_project_id != $working_copy_project_id) {
       $ok = phutil_console_confirm(
         "This diff is for the '{$bundle_project_id}' project but the working ".
         "copy belongs to the '{$working_copy_project_id}' project. ".
         "Still try to apply it?",
         $default_no = false
       );
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     // Check to see if the bundle's base revision matches the working copy
     // base revision
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api->supportsRelativeLocalCommits()) {
       $bundle_base_rev = $bundle->getBaseRevision();
       if (empty($bundle_base_rev)) {
         // this means $source is SOURCE_PATCH || SOURCE_BUNDLE w/ $version < 2
         // they don't have a base rev so just do nothing
         $commit_exists = true;
       } else {
         $commit_exists =
           $repository_api->hasLocalCommit($bundle_base_rev);
       }
       if (!$commit_exists) {
         // we have a problem...! lots of work because we need to ask
         // differential for revision information for these base revisions
         // to improve our error message.
         $bundle_base_rev_str = null;
         $source_base_rev     = $repository_api->getWorkingCopyRevision();
         $source_base_rev_str = null;
 
         if ($repository_api instanceof ArcanistGitAPI) {
           $hash_type = ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT;
         } else if ($repository_api instanceof ArcanistMercurialAPI) {
           $hash_type = ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT;
         } else {
           $hash_type = null;
         }
 
         if ($hash_type) {
           // 2 round trips because even though we could send off one query
           // we wouldn't be able to tell which revisions were for which hash
           $hash = array($hash_type, $bundle_base_rev);
           $bundle_revision = $this->loadRevisionFromHash($hash);
           $hash = array($hash_type, $source_base_rev);
           $source_revision = $this->loadRevisionFromHash($hash);
 
           if ($bundle_revision) {
             $bundle_base_rev_str = $bundle_base_rev .
                                    ' \ D' . $bundle_revision['id'];
           }
           if ($source_revision) {
             $source_base_rev_str = $source_base_rev .
                                    ' \ D' . $source_revision['id'];
           }
         }
         $bundle_base_rev_str = nonempty($bundle_base_rev_str,
                                         $bundle_base_rev);
         $source_base_rev_str = nonempty($source_base_rev_str,
                                         $source_base_rev);
 
         $ok = phutil_console_confirm(
           "This diff is against commit {$bundle_base_rev_str}, but the ".
           "commit is nowhere in the working copy. Try to apply it against ".
           "the current working copy state? ({$source_base_rev_str})",
           $default_no = false
         );
         if (!$ok) {
           throw new ArcanistUserAbortException();
         }
       }
     }
 
     // TODO -- more sanity checks here
   }
 
   /**
    * Create parent directories one at a time, since we need to "svn add" each
    * one. (Technically we could "svn add" just the topmost new directory.)
    */
   private function createParentDirectoryOf($path) {
     $repository_api = $this->getRepositoryAPI();
     $dir = dirname($path);
     if (Filesystem::pathExists($dir)) {
       return;
     } else {
       // Make sure the parent directory exists before we make this one.
       $this->createParentDirectoryOf($dir);
       execx(
         '(cd %s && mkdir %s)',
         $repository_api->getPath(),
         $dir);
       passthru(
         csprintf(
           '(cd %s && svn add %s)',
           $repository_api->getPath(),
           $dir));
     }
   }
 
   private function loadRevisionFromHash($hash) {
     // TODO -- de-hack this as permissions become more clear with things
     // like T848 (add scope to OAuth)
     if (!$this->isConduitAuthenticated()) {
       return null;
     }
 
     $conduit = $this->getConduit();
 
     $revisions = $conduit->callMethodSynchronous(
       'differential.query',
       array(
         'commitHashes' => array($hash),
       )
     );
 
 
     // grab the latest closed revision only
     $found_revision = null;
     $revisions = isort($revisions, 'dateModified');
     foreach ($revisions as $revision) {
       if ($revision['status'] == ArcanistDifferentialRevisionStatus::CLOSED) {
         $found_revision = $revision;
       }
     }
     return $found_revision;
   }
 }