diff --git a/src/lint/linter/ArcanistExternalLinter.php b/src/lint/linter/ArcanistExternalLinter.php
index 418a434a..83586081 100644
--- a/src/lint/linter/ArcanistExternalLinter.php
+++ b/src/lint/linter/ArcanistExternalLinter.php
@@ -1,473 +1,471 @@
 <?php
 
 /**
  * Base class for linters which operate by invoking an external program and
  * parsing results.
  *
  * @task bin      Interpreters, Binaries and Flags
  * @task parse    Parsing Linter Output
  * @task exec     Executing the Linter
  */
 abstract class ArcanistExternalLinter extends ArcanistFutureLinter {
 
   private $bin;
   private $interpreter;
   private $flags;
 
 
 /* -(  Interpreters, Binaries and Flags  )----------------------------------- */
 
   /**
    * Return the default binary name or binary path where the external linter
    * lives. This can either be a binary name which is expected to be installed
    * in PATH (like "jshint"), or a relative path from the project root
    * (like "resources/support/bin/linter") or an absolute path.
    *
    * If the binary needs an interpreter (like "python" or "node"), you should
    * also override @{method:shouldUseInterpreter} and provide the interpreter
    * in @{method:getDefaultInterpreter}.
    *
    * @return string Default binary to execute.
    * @task bin
    */
   abstract public function getDefaultBinary();
 
   /**
    * Return a human-readable string describing how to install the linter. This
    * is normally something like "Install such-and-such by running `npm install
    * -g such-and-such`.", but will differ from linter to linter.
    *
    * @return string Human readable install instructions
    * @task bin
    */
   abstract public function getInstallInstructions();
 
   /**
    * Return true to continue when the external linter exits with an error code.
    * By default, linters which exit with an error code are assumed to have
    * failed. However, some linters exit with a specific code to indicate that
    * lint messages were detected.
    *
    * If the linter sometimes raises errors during normal operation, override
    * this method and return true so execution continues when it exits with
    * a nonzero status.
    *
    * @param bool  Return true to continue on nonzero error code.
    * @task bin
    */
   public function shouldExpectCommandErrors() {
     return true;
   }
 
   /**
    * Provide mandatory, non-overridable flags to the linter. Generally these
    * are format flags, like `--format=xml`, which must always be given for
    * the output to be usable.
    *
    * Flags which are not mandatory should be provided in
    * @{method:getDefaultFlags} instead.
    *
    * @return list<string>  Mandatory flags, like `"--format=xml"`.
    * @task bin
    */
   protected function getMandatoryFlags() {
     return array();
   }
 
   /**
    * Provide default, overridable flags to the linter. Generally these are
    * configuration flags which affect behavior but aren't critical. Flags
    * which are required should be provided in @{method:getMandatoryFlags}
    * instead.
    *
    * Default flags can be overridden with @{method:setFlags}.
    *
    * @return list<string>  Overridable default flags.
    * @task bin
    */
   protected function getDefaultFlags() {
     return array();
   }
 
   /**
    * Override default flags with custom flags. If not overridden, flags provided
    * by @{method:getDefaultFlags} are used.
    *
    * @param list<string> New flags.
    * @return this
    * @task bin
    */
   final public function setFlags(array $flags) {
     $this->flags = $flags;
     return $this;
   }
 
   /**
    * Return the binary or script to execute. This method synthesizes defaults
    * and configuration. You can override the binary with @{method:setBinary}.
    *
    * @return string Binary to execute.
    * @task bin
    */
   final public function getBinary() {
     return coalesce($this->bin, $this->getDefaultBinary());
   }
 
   /**
    * Override the default binary with a new one.
    *
    * @param string  New binary.
    * @return this
    * @task bin
    */
   final public function setBinary($bin) {
     $this->bin = $bin;
     return $this;
   }
 
   /**
    * Return true if this linter should use an interpreter (like "python" or
    * "node") in addition to the script.
    *
    * After overriding this method to return `true`, override
    * @{method:getDefaultInterpreter} to set a default.
    *
    * @return bool True to use an interpreter.
    * @task bin
    */
   public function shouldUseInterpreter() {
     return false;
   }
 
   /**
    * Return the default interpreter, like "python" or "node". This method is
    * only invoked if @{method:shouldUseInterpreter} has been overridden to
    * return `true`.
    *
    * @return string Default interpreter.
    * @task bin
    */
   public function getDefaultInterpreter() {
     throw new PhutilMethodNotImplementedException();
   }
 
   /**
    * Get the effective interpreter. This method synthesizes configuration and
    * defaults.
    *
    * @return string Effective interpreter.
    * @task bin
    */
   final public function getInterpreter() {
     return coalesce($this->interpreter, $this->getDefaultInterpreter());
   }
 
   /**
    * Set the interpreter, overriding any default.
    *
    * @param string New interpreter.
    * @return this
    * @task bin
    */
   final public function setInterpreter($interpreter) {
     $this->interpreter = $interpreter;
     return $this;
   }
 
 
 /* -(  Parsing Linter Output  )---------------------------------------------- */
 
   /**
    * Parse the output of the external lint program into objects of class
    * @{class:ArcanistLintMessage} which `arc` can consume. Generally, this
    * means examining the output and converting each warning or error into a
    * message.
    *
    * If parsing fails, returning `false` will cause the caller to throw an
    * appropriate exception. (You can also throw a more specific exception if
    * you're able to detect a more specific condition.) Otherwise, return a list
    * of messages.
    *
    * @param  string   Path to the file being linted.
    * @param  int      Exit code of the linter.
    * @param  string   Stdout of the linter.
    * @param  string   Stderr of the linter.
    * @return list<ArcanistLintMessage>|false  List of lint messages, or false
    *                                          to indicate parser failure.
    * @task parse
    */
   abstract protected function parseLinterOutput($path, $err, $stdout, $stderr);
 
 
 /* -(  Executing the Linter  )----------------------------------------------- */
 
   /**
    * Check that the binary and interpreter (if applicable) exist, and throw
    * an exception with a message about how to install them if they do not.
    *
    * @return void
    */
   final public function checkBinaryConfiguration() {
     $interpreter = null;
     if ($this->shouldUseInterpreter()) {
       $interpreter = $this->getInterpreter();
     }
 
     $binary = $this->getBinary();
 
     // NOTE: If we have an interpreter, we don't require the script to be
     // executable (so we just check that the path exists). Otherwise, the
     // binary must be executable.
 
     if ($interpreter) {
       if (!Filesystem::binaryExists($interpreter)) {
         throw new ArcanistMissingLinterException(
           pht(
             'Unable to locate interpreter "%s" to run linter %s. You may need '.
             'to install the interpreter, or adjust your linter configuration.',
             $interpreter,
             get_class($this)));
       }
       if (!Filesystem::pathExists($binary)) {
         throw new ArcanistMissingLinterException(
           sprintf(
             "%s\n%s",
             pht(
               'Unable to locate script "%s" to run linter %s. You may need '.
               'to install the script, or adjust your linter configuration.',
               $binary,
               get_class($this)),
             pht(
               'TO INSTALL: %s',
               $this->getInstallInstructions())));
       }
     } else {
       if (!Filesystem::binaryExists($binary)) {
         throw new ArcanistMissingLinterException(
           sprintf(
             "%s\n%s",
             pht(
               'Unable to locate binary "%s" to run linter %s. You may need '.
               'to install the binary, or adjust your linter configuration.',
               $binary,
               get_class($this)),
             pht(
               'TO INSTALL: %s',
               $this->getInstallInstructions())));
       }
     }
   }
 
   /**
    * Get the composed executable command, including the interpreter and binary
    * but without flags or paths. This can be used to execute `--version`
    * commands.
    *
    * @return string Command to execute the raw linter.
    * @task exec
    */
   final protected function getExecutableCommand() {
     $this->checkBinaryConfiguration();
 
     $interpreter = null;
     if ($this->shouldUseInterpreter()) {
       $interpreter = $this->getInterpreter();
     }
 
     $binary = $this->getBinary();
 
     if ($interpreter) {
       $bin = csprintf('%s %s', $interpreter, $binary);
     } else {
       $bin = csprintf('%s', $binary);
     }
 
     return $bin;
   }
 
   /**
    * Get the composed flags for the executable, including both mandatory and
    * configured flags.
    *
    * @return list<string> Composed flags.
    * @task exec
    */
   final protected function getCommandFlags() {
     return array_merge(
       $this->getMandatoryFlags(),
       nonempty($this->flags, $this->getDefaultFlags()));
   }
 
   public function getCacheVersion() {
     try {
       $this->checkBinaryConfiguration();
     } catch (ArcanistMissingLinterException $e) {
       return null;
     }
 
     $version = $this->getVersion();
 
     if ($version) {
       return $version.'-'.json_encode($this->getCommandFlags());
     } else {
       // Either we failed to parse the version number or the `getVersion`
       // function hasn't been implemented.
       return json_encode($this->getCommandFlags());
     }
   }
 
   /**
    * Prepare the path to be added to the command string.
    *
    * This method is expected to return an already escaped string.
    *
    * @param string Path to the file being linted
    * @return string The command-ready file argument
    */
   protected function getPathArgumentForLinterFuture($path) {
     return csprintf('%s', $path);
   }
 
   final protected function buildFutures(array $paths) {
     $executable = $this->getExecutableCommand();
 
     $bin = csprintf('%C %Ls', $executable, $this->getCommandFlags());
 
     $futures = array();
     foreach ($paths as $path) {
       $disk_path = $this->getEngine()->getFilePathOnDisk($path);
       $path_argument = $this->getPathArgumentForLinterFuture($disk_path);
       $future = new ExecFuture('%C %C', $bin, $path_argument);
 
-      $future->setCWD($this->getEngine()->getWorkingCopy()->getProjectRoot());
+      $future->setCWD($this->getProjectRoot());
       $futures[$path] = $future;
     }
 
     return $futures;
   }
 
   final protected function resolveFuture($path, Future $future) {
     list($err, $stdout, $stderr) = $future->resolve();
     if ($err && !$this->shouldExpectCommandErrors()) {
       $future->resolvex();
     }
 
     $messages = $this->parseLinterOutput($path, $err, $stdout, $stderr);
 
     if ($messages === false) {
       if ($err) {
         $future->resolvex();
       } else {
         throw new Exception(
           sprintf(
             "%s\n\nSTDOUT\n%s\n\nSTDERR\n%s",
             pht('Linter failed to parse output!'),
             $stdout,
             $stderr));
       }
     }
 
     foreach ($messages as $message) {
       $this->addLintMessage($message);
     }
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
       'bin' => array(
         'type' => 'optional string | list<string>',
         'help' => pht(
           'Specify a string (or list of strings) identifying the binary '.
           'which should be invoked to execute this linter. This overrides '.
           'the default binary. If you provide a list of possible binaries, '.
           'the first one which exists will be used.'),
       ),
       'flags' => array(
         'type' => 'optional list<string>',
         'help' => pht(
           'Provide a list of additional flags to pass to the linter on the '.
           'command line.'),
       ),
     );
 
     if ($this->shouldUseInterpreter()) {
       $options['interpreter'] = array(
         'type' => 'optional string | list<string>',
         'help' => pht(
           'Specify a string (or list of strings) identifying the interpreter '.
           'which should be used to invoke the linter binary. If you provide '.
           'a list of possible interpreters, the first one that exists '.
           'will be used.'),
       );
     }
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'interpreter':
-        $working_copy = $this->getEngine()->getWorkingCopy();
-        $root = $working_copy->getProjectRoot();
+        $root = $this->getProjectRoot();
 
         foreach ((array)$value as $path) {
           if (Filesystem::binaryExists($path)) {
             $this->setInterpreter($path);
             return;
           }
 
           $path = Filesystem::resolvePath($path, $root);
 
           if (Filesystem::binaryExists($path)) {
             $this->setInterpreter($path);
             return;
           }
         }
 
         throw new Exception(
           pht('None of the configured interpreters can be located.'));
       case 'bin':
         $is_script = $this->shouldUseInterpreter();
 
-        $working_copy = $this->getEngine()->getWorkingCopy();
-        $root = $working_copy->getProjectRoot();
+        $root = $this->getProjectRoot();
 
         foreach ((array)$value as $path) {
           if (!$is_script && Filesystem::binaryExists($path)) {
             $this->setBinary($path);
             return;
           }
 
           $path = Filesystem::resolvePath($path, $root);
           if ((!$is_script && Filesystem::binaryExists($path)) ||
               ($is_script && Filesystem::pathExists($path))) {
             $this->setBinary($path);
             return;
           }
         }
 
         throw new Exception(
           pht('None of the configured binaries can be located.'));
       case 'flags':
         $this->setFlags($value);
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   /**
    * Map a configuration lint code to an `arc` lint code. Primarily, this is
    * intended for validation, but can also be used to normalize case or
    * otherwise be more permissive in accepted inputs.
    *
    * If the code is not recognized, you should throw an exception.
    *
    * @param string  Code specified in configuration.
    * @return string  Normalized code to use in severity map.
    */
   protected function getLintCodeFromLinterConfigurationKey($code) {
     return $code;
   }
 
 }
diff --git a/src/lint/linter/ArcanistLinter.php b/src/lint/linter/ArcanistLinter.php
index aae1fbbd..b7def163 100644
--- a/src/lint/linter/ArcanistLinter.php
+++ b/src/lint/linter/ArcanistLinter.php
@@ -1,650 +1,668 @@
 <?php
 
 /**
  * Implements lint rules, like syntax checks for a specific language.
  *
  * @task info Human Readable Information
  * @task state Runtime State
  * @task exec Executing Linters
  * @stable
  */
 abstract class ArcanistLinter {
 
   const GRANULARITY_FILE = 1;
   const GRANULARITY_DIRECTORY = 2;
   const GRANULARITY_REPOSITORY = 3;
   const GRANULARITY_GLOBAL = 4;
 
   private $id;
   protected $paths = array();
   private $filteredPaths = null;
   protected $data = array();
   protected $engine;
   protected $activePath;
   protected $messages = array();
 
   protected $stopAllLinters = false;
 
   private $customSeverityMap = array();
   private $customSeverityRules = array();
 
 
 /*  -(  Human Readable Information  )---------------------------------------- */
 
 
   /**
    * Return an optional informative URI where humans can learn more about this
    * linter.
    *
    * For most linters, this should return a link to the project home page. This
    * is shown on `arc linters`.
    *
    * @return string|null Optionally, return an informative URI.
    * @task info
    */
   public function getInfoURI() {
     return null;
   }
 
   /**
    * Return a brief human-readable description of the linter.
    *
    * These should be a line or two, and are shown on `arc linters`.
    *
    * @return string|null Optionally, return a brief human-readable description.
    * @task info
    */
   public function getInfoDescription() {
     return null;
   }
 
   /**
    * Return a human-readable linter name.
    *
    * These are used by `arc linters`, and can let you give a linter a more
    * presentable name.
    *
    * @return string Human-readable linter name.
    * @task info
    */
   public function getInfoName() {
     return nonempty(
       $this->getLinterName(),
       $this->getLinterConfigurationName(),
       get_class($this));
   }
 
 
 /* -(  Runtime State  )------------------------------------------------------ */
 
 
   /**
    * @task state
    */
   final public function getActivePath() {
     return $this->activePath;
   }
 
 
   /**
    * @task state
    */
   final public function setActivePath($path) {
     $this->stopAllLinters = false;
     $this->activePath = $path;
     return $this;
   }
 
 
   /**
    * @task state
    */
   final public function setEngine(ArcanistLintEngine $engine) {
     $this->engine = $engine;
     return $this;
   }
 
 
   /**
    * @task state
    */
   final protected function getEngine() {
     return $this->engine;
   }
 
 
   /**
    * Set the internal ID for this linter.
    *
    * This ID is assigned automatically by the @{class:ArcanistLintEngine}.
    *
    * @param string Unique linter ID.
    * @return this
    * @task state
    */
   final public function setLinterID($id) {
     $this->id = $id;
     return $this;
   }
 
 
   /**
    * Get the internal ID for this linter.
    *
    * Retrieves an internal linter ID managed by the @{class:ArcanistLintEngine}.
    * This ID is a unique scalar which distinguishes linters in a list.
    *
    * @return string Unique linter ID.
    * @task state
    */
   final public function getLinterID() {
     return $this->id;
   }
 
 
 /* -(  Executing Linters  )-------------------------------------------------- */
 
 
   /**
    * Hook called before a list of paths are linted.
    *
    * Parallelizable linters can start multiple requests in parallel here,
    * to improve performance. They can implement @{method:didLintPaths} to
    * collect results.
    *
    * Linters which are not parallelizable should normally ignore this callback
    * and implement @{method:lintPath} instead.
    *
    * @param list<string> A list of paths to be linted
    * @return void
    * @task exec
    */
   public function willLintPaths(array $paths) {
     return;
   }
 
 
   /**
    * Hook called for each path to be linted.
    *
    * Linters which are not parallelizable can do work here.
    *
    * Linters which are parallelizable may want to ignore this callback and
    * implement @{method:willLintPaths} and @{method:didLintPaths} instead.
    *
    * @param string Path to lint.
    * @return void
    * @task exec
    */
   public function lintPath($path) {
     return;
   }
 
 
   /**
    * Hook called after a list of paths are linted.
    *
    * Parallelizable linters can collect results here.
    *
    * Linters which are not paralleizable should normally ignore this callback
    * and implement @{method:lintPath} instead.
    *
    * @param list<string> A list of paths which were linted.
    * @return void
    * @task exec
    */
   public function didLintPaths(array $paths) {
     return;
   }
 
 
   /**
    * Obsolete hook which was invoked before a path was linted.
    *
    * WARNING: This is an obsolete hook which is not called. If you maintain
    * a linter which relies on it, update to use @{method:lintPath} instead.
    *
    * @task exec
    */
   final public function willLintPath($path) {
     // TODO: Remove this method after some time. In the meantime, the "final"
     // will fatal subclasses which implement this hook and point at the API
     // change so maintainers get fewer surprises.
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * Obsolete hook which was invoked after linters ran.
    *
    * WARNING: This is an obsolete hook which is not called. If you maintain
    * a linter which relies on it, update to use @{method:didLintPaths} instead.
    *
    * @return void
    * @task exec
    */
   final public function didRunLinters() {
     // TODO: Remove this method after some time. In the meantime, the "final"
     // will fatal subclasses which implement this hook and point at the API
     // change so maintainers get fewer surprises.
     throw new PhutilMethodNotImplementedException();
   }
 
 
   public function getLinterPriority() {
     return 1.0;
   }
 
   /**
    * TODO: This should be `final`.
    */
   public function setCustomSeverityMap(array $map) {
     $this->customSeverityMap = $map;
     return $this;
   }
 
   final public function setCustomSeverityRules(array $rules) {
     $this->customSeverityRules = $rules;
     return $this;
   }
 
+  final public function getProjectRoot() {
+    $engine = $this->getEngine();
+    if (!$engine) {
+      throw new Exception(
+        pht(
+          'You must call %s before you can call %s.',
+          'setEngine()',
+          __FUNCTION__.'()'));
+    }
+
+    $working_copy = $engine->getWorkingCopy();
+    if (!$working_copy) {
+      return null;
+    }
+
+    return $working_copy->getProjectRoot();
+  }
+
   final public function getOtherLocation($offset, $path = null) {
     if ($path === null) {
       $path = $this->getActivePath();
     }
 
     list($line, $char) = $this->getEngine()->getLineAndCharFromOffset(
       $path,
       $offset);
 
     return array(
       'path' => $path,
       'line' => $line + 1,
       'char' => $char,
     );
   }
 
   final public function stopAllLinters() {
     $this->stopAllLinters = true;
     return $this;
   }
 
   final public function didStopAllLinters() {
     return $this->stopAllLinters;
   }
 
   final public function addPath($path) {
     $this->paths[$path] = $path;
     $this->filteredPaths = null;
     return $this;
   }
 
   final public function setPaths(array $paths) {
     $this->paths = $paths;
     $this->filteredPaths = null;
     return $this;
   }
 
   /**
    * Filter out paths which this linter doesn't act on (for example, because
    * they are binaries and the linter doesn't apply to binaries).
    *
    * @param  list<string>
    * @return list<string>
    */
   final private function filterPaths(array $paths) {
     $engine = $this->getEngine();
 
     $keep = array();
     foreach ($paths as $path) {
       if (!$this->shouldLintDeletedFiles() && !$engine->pathExists($path)) {
         continue;
       }
 
       if (!$this->shouldLintDirectories() && $engine->isDirectory($path)) {
         continue;
       }
 
       if (!$this->shouldLintBinaryFiles() && $engine->isBinaryFile($path)) {
         continue;
       }
 
       if (!$this->shouldLintSymbolicLinks() && $engine->isSymbolicLink($path)) {
         continue;
       }
 
       $keep[] = $path;
     }
 
     return $keep;
   }
 
   final public function getPaths() {
     if ($this->filteredPaths === null) {
       $this->filteredPaths = $this->filterPaths(array_values($this->paths));
     }
 
     return $this->filteredPaths;
   }
 
   final public function addData($path, $data) {
     $this->data[$path] = $data;
     return $this;
   }
 
   final protected function getData($path) {
     if (!array_key_exists($path, $this->data)) {
       $this->data[$path] = $this->getEngine()->loadData($path);
     }
     return $this->data[$path];
   }
 
   public function getCacheVersion() {
     return 0;
   }
 
 
   final public function getLintMessageFullCode($short_code) {
     return $this->getLinterName().$short_code;
   }
 
   final public function getLintMessageSeverity($code) {
     $map = $this->customSeverityMap;
     if (isset($map[$code])) {
       return $map[$code];
     }
 
     foreach ($this->customSeverityRules as $rule => $severity) {
       if (preg_match($rule, $code)) {
         return $severity;
       }
     }
 
     $map = $this->getLintSeverityMap();
     if (isset($map[$code])) {
       return $map[$code];
     }
 
     return $this->getDefaultMessageSeverity($code);
   }
 
   protected function getDefaultMessageSeverity($code) {
     return ArcanistLintSeverity::SEVERITY_ERROR;
   }
 
   final public function isMessageEnabled($code) {
     return ($this->getLintMessageSeverity($code) !==
             ArcanistLintSeverity::SEVERITY_DISABLED);
   }
 
   final public function getLintMessageName($code) {
     $map = $this->getLintNameMap();
     if (isset($map[$code])) {
       return $map[$code];
     }
     return pht('Unknown lint message!');
   }
 
   final protected function addLintMessage(ArcanistLintMessage $message) {
-    $root = $this->getEngine()->getWorkingCopy()->getProjectRoot();
+    $root = $this->getProjectRoot();
     $path = Filesystem::resolvePath($message->getPath(), $root);
     $message->setPath(Filesystem::readablePath($path, $root));
 
     $this->messages[] = $message;
     return $message;
   }
 
   final public function getLintMessages() {
     return $this->messages;
   }
 
   final protected function raiseLintAtLine(
     $line,
     $char,
     $code,
     $desc,
     $original = null,
     $replacement = null) {
 
     $message = id(new ArcanistLintMessage())
       ->setPath($this->getActivePath())
       ->setLine($line)
       ->setChar($char)
       ->setCode($this->getLintMessageFullCode($code))
       ->setSeverity($this->getLintMessageSeverity($code))
       ->setName($this->getLintMessageName($code))
       ->setDescription($desc)
       ->setOriginalText($original)
       ->setReplacementText($replacement);
 
     return $this->addLintMessage($message);
   }
 
   final protected function raiseLintAtPath($code, $desc) {
     return $this->raiseLintAtLine(null, null, $code, $desc, null, null);
   }
 
   final protected function raiseLintAtOffset(
     $offset,
     $code,
     $desc,
     $original = null,
     $replacement = null) {
 
     $path = $this->getActivePath();
     $engine = $this->getEngine();
     if ($offset === null) {
       $line = null;
       $char = null;
     } else {
       list($line, $char) = $engine->getLineAndCharFromOffset($path, $offset);
     }
 
     return $this->raiseLintAtLine(
       $line + 1,
       $char + 1,
       $code,
       $desc,
       $original,
       $replacement);
   }
 
   public function canRun() {
     return true;
   }
 
   abstract public function getLinterName();
 
   public function getVersion() {
     return null;
   }
 
   final protected function isCodeEnabled($code) {
     $severity = $this->getLintMessageSeverity($code);
     return $this->getEngine()->isSeverityEnabled($severity);
   }
 
   public function getLintSeverityMap() {
     return array();
   }
 
   public function getLintNameMap() {
     return array();
   }
 
   public function getCacheGranularity() {
     return self::GRANULARITY_FILE;
   }
 
   /**
    * If this linter is selectable via `.arclint` configuration files, return
    * a short, human-readable name to identify it. For example, `"jshint"` or
    * `"pep8"`.
    *
    * If you do not implement this method, the linter will not be selectable
    * through `.arclint` files.
    */
   public function getLinterConfigurationName() {
     return null;
   }
 
   public function getLinterConfigurationOptions() {
     if (!$this->canCustomizeLintSeverities()) {
       return array();
     }
 
     return array(
       'severity' => array(
         'type' => 'optional map<string|int, string>',
         'help' => pht(
           'Provide a map from lint codes to adjusted severity levels: error, '.
           'warning, advice, autofix or disabled.'),
       ),
       'severity.rules' => array(
         'type' => 'optional map<string, string>',
         'help' => pht(
           'Provide a map of regular expressions to severity levels. All '.
           'matching codes have their severity adjusted.'),
       ),
     );
   }
 
   public function setLinterConfigurationValue($key, $value) {
     $sev_map = array(
       'error'    => ArcanistLintSeverity::SEVERITY_ERROR,
       'warning'  => ArcanistLintSeverity::SEVERITY_WARNING,
       'autofix'  => ArcanistLintSeverity::SEVERITY_AUTOFIX,
       'advice'   => ArcanistLintSeverity::SEVERITY_ADVICE,
       'disabled' => ArcanistLintSeverity::SEVERITY_DISABLED,
     );
 
     switch ($key) {
       case 'severity':
         if (!$this->canCustomizeLintSeverities()) {
           break;
         }
 
         $custom = array();
         foreach ($value as $code => $severity) {
           if (empty($sev_map[$severity])) {
             $valid = implode(', ', array_keys($sev_map));
             throw new Exception(
               pht(
                 'Unknown lint severity "%s". Valid severities are: %s.',
                 $severity,
                 $valid));
           }
           $code = $this->getLintCodeFromLinterConfigurationKey($code);
           $custom[$code] = $severity;
         }
 
         $this->setCustomSeverityMap($custom);
         return;
 
       case 'severity.rules':
         if (!$this->canCustomizeLintSeverities()) {
           break;
         }
 
         foreach ($value as $rule => $severity) {
           if (@preg_match($rule, '') === false) {
             throw new Exception(
               pht(
                 'Severity rule "%s" is not a valid regular expression.',
                 $rule));
           }
           if (empty($sev_map[$severity])) {
             $valid = implode(', ', array_keys($sev_map));
             throw new Exception(
               pht(
                 'Unknown lint severity "%s". Valid severities are: %s.',
                 $severity,
                 $valid));
           }
         }
         $this->setCustomSeverityRules($value);
         return;
     }
 
     throw new Exception(pht('Incomplete implementation: %s!', $key));
   }
 
   protected function canCustomizeLintSeverities() {
     return true;
   }
 
   protected function shouldLintBinaryFiles() {
     return false;
   }
 
   protected function shouldLintDeletedFiles() {
     return false;
   }
 
   protected function shouldLintDirectories() {
     return false;
   }
 
   protected function shouldLintSymbolicLinks() {
     return false;
   }
 
   /**
    * Map a configuration lint code to an `arc` lint code. Primarily, this is
    * intended for validation, but can also be used to normalize case or
    * otherwise be more permissive in accepted inputs.
    *
    * If the code is not recognized, you should throw an exception.
    *
    * @param string  Code specified in configuration.
    * @return string  Normalized code to use in severity map.
    */
   protected function getLintCodeFromLinterConfigurationKey($code) {
     return $code;
   }
 
   /**
    * Retrieve an old lint configuration value from `.arcconfig` or a similar
    * source.
    *
    * Modern linters should use @{method:getConfig} to read configuration from
    * `.arclint`.
    *
    * @param   string  Configuration key to retrieve.
    * @param   wild    Default value to return if key is not present in config.
    * @return  wild    Configured value, or default if no configuration exists.
    */
   final protected function getDeprecatedConfiguration($key, $default = null) {
     // If we're being called in a context without an engine (probably from
     // `arc linters`), just return the default value.
     if (!$this->engine) {
       return $default;
     }
 
     $config = $this->getEngine()->getConfigurationManager();
 
     // Construct a sentinel object so we can tell if we're reading config
     // or not.
     $sentinel = (object)array();
     $result = $config->getConfigFromAnySource($key, $sentinel);
 
     // If we read config, warn the user that this mechanism is deprecated and
     // discouraged.
     if ($result !== $sentinel) {
       $console = PhutilConsole::getConsole();
       $console->writeErr(
         "**%s**: %s\n",
         pht('Deprecation Warning'),
         pht(
           'Configuration option "%s" is deprecated. Generally, linters should '.
           'now be configured using an `%s` file. See "Arcanist User '.
           'Guide: Lint" in the documentation for more information.',
           $key,
           '.arclint'));
       return $result;
     }
 
     return $default;
   }
 
 }
diff --git a/src/lint/linter/ArcanistScriptAndRegexLinter.php b/src/lint/linter/ArcanistScriptAndRegexLinter.php
index 8e8a1f5c..af2ebb95 100644
--- a/src/lint/linter/ArcanistScriptAndRegexLinter.php
+++ b/src/lint/linter/ArcanistScriptAndRegexLinter.php
@@ -1,450 +1,450 @@
 <?php
 
 /**
  * Simple glue linter which runs some script on each path, and then uses a
  * regex to parse lint messages from the script's output. (This linter uses a
  * script and a regex to interpret the results of some real linter, it does
  * not itself lint both scripts and regexes).
  *
  * Configure this linter by setting these keys in your .arclint section:
  *
  *  - `script-and-regex.script` Script command to run. This can be
  *    the path to a linter script, but may also include flags or use shell
  *    features (see below for examples).
  *  - `script-and-regex.regex` The regex to process output with. This
  *    regex uses named capturing groups (detailed below) to interpret output.
  *
  * The script will be invoked from the project root, so you can specify a
  * relative path like `scripts/lint.sh` or an absolute path like
  * `/opt/lint/lint.sh`.
  *
  * This linter is necessarily more limited in its capabilities than a normal
  * linter which can perform custom processing, but may be somewhat simpler to
  * configure.
  *
  * == Script... ==
  *
  * The script will be invoked once for each file that is to be linted, with
  * the file passed as the first argument. The file may begin with a "-"; ensure
  * your script will not interpret such files as flags (perhaps by ending your
  * script configuration with "--", if its argument parser supports that).
  *
  * Note that when run via `arc diff`, the list of files to be linted includes
  * deleted files and files that were moved away by the change. The linter should
  * not assume the path it is given exists, and it is not an error for the
  * linter to be invoked with paths which are no longer there. (Every affected
  * path is subject to lint because some linters may raise errors in other files
  * when a file is removed, or raise an error about its removal.)
  *
  * The script should emit lint messages to stdout, which will be parsed with
  * the provided regex.
  *
  * For example, you might use a configuration like this:
  *
  *   /opt/lint/lint.sh --flag value --other-flag --
  *
  * stderr is ignored. If you have a script which writes messages to stderr,
  * you can redirect stderr to stdout by using a configuration like this:
  *
  *   sh -c '/opt/lint/lint.sh "$0" 2>&1'
  *
  * The return code of the script must be 0, or an exception will be raised
  * reporting that the linter failed. If you have a script which exits nonzero
  * under normal circumstances, you can force it to always exit 0 by using a
  * configuration like this:
  *
  *   sh -c '/opt/lint/lint.sh "$0" || true'
  *
  * Multiple instances of the script will be run in parallel if there are
  * multiple files to be linted, so they should not use any unique resources.
  * For instance, this configuration would not work properly, because several
  * processes may attempt to write to the file at the same time:
  *
  *   COUNTEREXAMPLE
  *   sh -c '/opt/lint/lint.sh --output /tmp/lint.out "$0" && cat /tmp/lint.out'
  *
  * There are necessary limits to how gracefully this linter can deal with
  * edge cases, because it is just a script and a regex. If you need to do
  * things that this linter can't handle, you can write a phutil linter and move
  * the logic to handle those cases into PHP. PHP is a better general-purpose
  * programming language than regular expressions are, if only by a small margin.
  *
  * == ...and Regex ==
  *
  * The regex must be a valid PHP PCRE regex, including delimiters and flags.
  *
  * The regex will be matched against the entire output of the script, so it
  * should generally be in this form if messages are one-per-line:
  *
  *   /^...$/m
  *
  * The regex should capture these named patterns with `(?P<name>...)`:
  *
  *   - `message` (required) Text describing the lint message. For example,
  *     "This is a syntax error.".
  *   - `name` (optional) Text summarizing the lint message. For example,
  *     "Syntax Error".
  *   - `severity` (optional) The word "error", "warning", "autofix", "advice",
  *     or "disabled", in any combination of upper and lower case. Instead, you
  *     may match groups called `error`, `warning`, `advice`, `autofix`, or
  *     `disabled`. These allow you to match output formats like "E123" and
  *     "W123" to indicate errors and warnings, even though the word "error" is
  *     not present in the output. If no severity capturing group is present,
  *     messages are raised with "error" severity. If multiple severity capturing
  *     groups are present, messages are raised with the highest captured
  *     severity. Capturing groups like `error` supersede the `severity`
  *     capturing group.
  *   - `error` (optional) Match some nonempty substring to indicate that this
  *     message has "error" severity.
  *   - `warning` (optional) Match some nonempty substring to indicate that this
  *     message has "warning" severity.
  *   - `advice` (optional) Match some nonempty substring to indicate that this
  *     message has "advice" severity.
  *   - `autofix` (optional) Match some nonempty substring to indicate that this
  *     message has "autofix" severity.
  *   - `disabled` (optional) Match some nonempty substring to indicate that this
  *     message has "disabled" severity.
  *   - `file` (optional) The name of the file to raise the lint message in. If
  *     not specified, defaults to the linted file. It is generally not necessary
  *     to capture this unless the linter can raise messages in files other than
  *     the one it is linting.
  *   - `line` (optional) The line number of the message.
  *   - `char` (optional) The character offset of the message.
  *   - `offset` (optional) The byte offset of the message. If captured, this
  *     supersedes `line` and `char`.
  *   - `original` (optional) The text the message affects.
  *   - `replacement` (optional) The text that the range captured by `original`
  *     should be automatically replaced by to resolve the message.
  *   - `code` (optional) A short error type identifier which can be used
  *     elsewhere to configure handling of specific types of messages. For
  *     example, "EXAMPLE1", "EXAMPLE2", etc., where each code identifies a
  *     class of message like "syntax error", "missing whitespace", etc. This
  *     allows configuration to later change the severity of all whitespace
  *     messages, for example.
  *   - `ignore` (optional) Match some nonempty substring to ignore the match.
  *     You can use this if your linter sometimes emits text like "No lint
  *     errors".
  *   - `stop` (optional) Match some nonempty substring to stop processing input.
  *     Remaining matches for this file will be discarded, but linting will
  *     continue with other linters and other files.
  *   - `halt` (optional) Match some nonempty substring to halt all linting of
  *     this file by any linter. Linting will continue with other files.
  *   - `throw` (optional) Match some nonempty substring to throw an error, which
  *     will stop `arc` completely. You can use this to fail abruptly if you
  *     encounter unexpected output. All processing will abort.
  *
  * Numbered capturing groups are ignored.
  *
  * For example, if your lint script's output looks like this:
  *
  *   error:13 Too many goats!
  *   warning:22 Not enough boats.
  *
  * ...you could use this regex to parse it:
  *
  *   /^(?P<severity>warning|error):(?P<line>\d+) (?P<message>.*)$/m
  *
  * The simplest valid regex for line-oriented output is something like this:
  *
  *   /^(?P<message>.*)$/m
  *
  * @task  lint        Linting
  * @task  linterinfo  Linter Information
  * @task  parse       Parsing Output
  * @task  config      Validating Configuration
  */
 final class ArcanistScriptAndRegexLinter extends ArcanistLinter {
 
   private $script = null;
   private $regex = null;
   private $output = array();
 
   public function getInfoName() {
     return pht('Script and Regex');
   }
 
   public function getInfoDescription() {
     return pht(
       'Run an external script, then parse its output with a regular '.
       'expression. This is a generic binding that can be used to '.
       'run custom lint scripts.');
   }
 
 /* -(  Linting  )------------------------------------------------------------ */
 
 
   /**
    * Run the script on each file to be linted.
    *
    * @task lint
    */
   public function willLintPaths(array $paths) {
     $script = $this->getConfiguredScript();
-    $root   = $this->getEngine()->getWorkingCopy()->getProjectRoot();
+    $root   = $this->getProjectRoot();
 
     $futures = array();
     foreach ($paths as $path) {
       $future = new ExecFuture('%C %s', $script, $path);
       $future->setCWD($root);
       $futures[$path] = $future;
     }
 
     $futures = id(new FutureIterator($futures))
       ->limit(4);
     foreach ($futures as $path => $future) {
       list($stdout) = $future->resolvex();
       $this->output[$path] = $stdout;
     }
   }
 
   /**
    * Run the regex on the output of the script.
    *
    * @task lint
    */
   public function lintPath($path) {
     $regex = $this->getConfiguredRegex();
 
     $output = idx($this->output, $path);
     if (!strlen($output)) {
       // No output, but it exited 0, so just move on.
       return;
     }
 
     $matches = null;
     if (!preg_match_all($regex, $output, $matches, PREG_SET_ORDER)) {
       // Output with no matches. This might be a configuration error, but more
       // likely it's something like "No lint errors." and the user just hasn't
       // written a sufficiently powerful/ridiculous regexp to capture it into an
       // 'ignore' group. Don't make them figure this out; advanced users can
       // capture 'throw' to handle this case.
       return;
     }
 
     foreach ($matches as $match) {
       if (!empty($match['throw'])) {
         $throw = $match['throw'];
         throw new ArcanistUsageException(
           pht(
             "%s: configuration captured a '%s' named capturing group, ".
             "'%s'. Script output:\n%s",
             __CLASS__,
             'throw',
             $throw,
             $output));
       }
 
       if (!empty($match['halt'])) {
         $this->stopAllLinters();
         break;
       }
 
       if (!empty($match['stop'])) {
         break;
       }
 
       if (!empty($match['ignore'])) {
         continue;
       }
 
       list($line, $char) = $this->getMatchLineAndChar($match, $path);
 
       $dict = array(
         'path'        => idx($match, 'file', $path),
         'line'        => $line,
         'char'        => $char,
         'code'        => idx($match, 'code', $this->getLinterName()),
         'severity'    => $this->getMatchSeverity($match),
         'name'        => idx($match, 'name', 'Lint'),
         'description' => idx($match, 'message', pht('Undefined Lint Message')),
       );
 
       $original = idx($match, 'original');
       if ($original !== null) {
         $dict['original'] = $original;
       }
 
       $replacement = idx($match, 'replacement');
       if ($replacement !== null) {
         $dict['replacement'] = $replacement;
       }
 
       $lint = ArcanistLintMessage::newFromDictionary($dict);
       $this->addLintMessage($lint);
     }
   }
 
 
 /* -(  Linter Information  )------------------------------------------------- */
 
   /**
    * Return the short name of the linter.
    *
    * @return string Short linter identifier.
    *
    * @task linterinfo
    */
   public function getLinterName() {
     return 'S&RX';
   }
 
   public function getLinterConfigurationName() {
     return 'script-and-regex';
   }
 
   public function getLinterConfigurationOptions() {
     // These fields are optional only to avoid breaking things.
     $options = array(
       'script-and-regex.script' => array(
         'type' => 'optional string',
         'help' => pht('Script to execute.'),
       ),
       'script-and-regex.regex' => array(
         'type' => 'optional regex',
         'help' => pht('The regex to process output with.'),
       ),
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'script-and-regex.script':
         $this->script = $value;
         return;
       case 'script-and-regex.regex':
         $this->regex = $value;
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
 /* -(  Parsing Output  )----------------------------------------------------- */
 
   /**
    * Get the line and character of the message from the regex match.
    *
    * @param dict Captured groups from regex.
    * @return pair<int,int> Line and character of the message.
    *
    * @task parse
    */
   private function getMatchLineAndChar(array $match, $path) {
     if (!empty($match['offset'])) {
       list($line, $char) = $this->getEngine()->getLineAndCharFromOffset(
         idx($match, 'file', $path),
         $match['offset']);
       return array($line + 1, $char + 1);
     }
 
     $line = idx($match, 'line', 1);
     $char = idx($match, 'char');
 
     return array($line, $char);
   }
 
   /**
    * Map the regex matching groups to a message severity. We look for either
    * a nonempty severity name group like 'error', or a group called 'severity'
    * with a valid name.
    *
    * @param dict Captured groups from regex.
    * @return const  @{class:ArcanistLintSeverity} constant.
    *
    * @task parse
    */
   private function getMatchSeverity(array $match) {
     $map = array(
       'error'    => ArcanistLintSeverity::SEVERITY_ERROR,
       'warning'  => ArcanistLintSeverity::SEVERITY_WARNING,
       'autofix'  => ArcanistLintSeverity::SEVERITY_AUTOFIX,
       'advice'   => ArcanistLintSeverity::SEVERITY_ADVICE,
       'disabled' => ArcanistLintSeverity::SEVERITY_DISABLED,
     );
 
     $severity_name = strtolower(idx($match, 'severity'));
 
     foreach ($map as $name => $severity) {
       if (!empty($match[$name])) {
         return $severity;
       } else if ($severity_name == $name) {
         return $severity;
       }
     }
 
     return ArcanistLintSeverity::SEVERITY_ERROR;
   }
 
 
 /* -(  Validating Configuration  )------------------------------------------- */
 
   /**
    * Load, validate, and return the "script" configuration.
    *
    * @return string The shell command fragment to use to run the linter.
    *
    * @task config
    */
   private function getConfiguredScript() {
     if (strlen($this->script)) {
       return $this->script;
     }
 
     $config = $this->getDeprecatedConfiguration('linter.scriptandregex.script');
 
     if (!$config) {
       throw new ArcanistUsageException(
         pht(
           'No "script" configured for script-and-regex linter, which '.
           'requires a script. Use "%s" to configure one.',
           'script-and-regex.script'));
     }
 
     // NOTE: No additional validation since the "script" can be some random
     // shell command and/or include flags, so it does not need to point to some
     // file on disk.
 
     return $config;
   }
 
   /**
    * Load, validate, and return the "regex" configuration.
    *
    * @return string A valid PHP PCRE regular expression.
    *
    * @task config
    */
   private function getConfiguredRegex() {
     if (strlen($this->regex)) {
       return $this->regex;
     }
 
     $key = 'linter.scriptandregex.regex';
     $config = $this->getDeprecatedConfiguration($key);
 
     if (!$config) {
       throw new ArcanistUsageException(
         pht(
           'No "regex" configured for script-and-regex linter, which '.
           'requires a regex. Use "%s" to configure one.',
           'script-and-regex.regex'));
     }
 
     // NOTE: preg_match() returns 0 for no matches and false for compile error;
     // this won't match, but will validate the syntax of the regex.
 
     $ok = @preg_match($config, 'syntax-check');
     if ($ok === false) {
       throw new ArcanistUsageException(
         pht(
           'Regular expression passed to script-and-regex linter ("%s") is '.
           'not a valid regular expression.',
           $config));
     }
 
     return $config;
   }
 
 }
diff --git a/src/lint/linter/ArcanistSpellingLinter.php b/src/lint/linter/ArcanistSpellingLinter.php
index d22e67fb..f27bc906 100644
--- a/src/lint/linter/ArcanistSpellingLinter.php
+++ b/src/lint/linter/ArcanistSpellingLinter.php
@@ -1,182 +1,182 @@
 <?php
 
 /**
  * Enforces basic spelling. Spelling inside code is actually pretty hard to
  * get right without false positives. I take a conservative approach and just
  * use a blacklisted set of words that are commonly spelled incorrectly.
  */
 final class ArcanistSpellingLinter extends ArcanistLinter {
 
   const LINT_SPELLING_EXACT   = 1;
   const LINT_SPELLING_PARTIAL = 2;
 
   private $dictionaries     = array();
   private $exactWordRules   = array();
   private $partialWordRules = array();
 
   public function getInfoName() {
     return pht('Spellchecker');
   }
 
   public function getInfoDescription() {
     return pht('Detects common misspellings of English words.');
   }
 
   public function getLinterName() {
     return 'SPELL';
   }
 
   public function getLinterConfigurationName() {
     return 'spelling';
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
       'spelling.dictionaries' => array(
         'type' => 'optional list<string>',
         'help' => pht('Pass in custom dictionaries.'),
       ),
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'spelling.dictionaries':
         foreach ($value as $dictionary) {
           $this->loadDictionary($dictionary);
         }
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   public function loadDictionary($path) {
-    $root = $this->getEngine()->getWorkingCopy()->getProjectRoot();
+    $root = $this->getProjectRoot();
     $path = Filesystem::resolvePath($path, $root);
 
     $dict = phutil_json_decode(Filesystem::readFile($path));
     PhutilTypeSpec::checkMap(
       $dict,
       array(
         'rules' => 'map<string, map<string, string>>',
       ));
     $rules = $dict['rules'];
 
     $this->dictionaries[] = $path;
     $this->exactWordRules = array_merge(
       $this->exactWordRules,
       idx($rules, 'exact', array()));
     $this->partialWordRules = array_merge(
       $this->partialWordRules,
       idx($rules, 'partial', array()));
   }
 
   public function addExactWordRule($misspelling, $correction) {
     $this->exactWordRules = array_merge(
       $this->exactWordRules,
       array($misspelling => $correction));
   }
 
   public function addPartialWordRule($misspelling, $correction) {
     $this->partialWordRules = array_merge(
       $this->partialWordRules,
       array($misspelling => $correction));
   }
 
   public function getLintSeverityMap() {
     return array(
       self::LINT_SPELLING_EXACT   => ArcanistLintSeverity::SEVERITY_WARNING,
       self::LINT_SPELLING_PARTIAL => ArcanistLintSeverity::SEVERITY_WARNING,
     );
   }
 
   public function getLintNameMap() {
     return array(
       self::LINT_SPELLING_EXACT   => pht('Possible Spelling Mistake'),
       self::LINT_SPELLING_PARTIAL => pht('Possible Spelling Mistake'),
     );
   }
 
   public function lintPath($path) {
     // TODO: This is a bit hacky. If no dictionaries were specified, then add
     // the default dictionary.
     if (!$this->dictionaries) {
       $root = dirname(phutil_get_library_root('arcanist'));
       $this->loadDictionary($root.'/resources/spelling/english.json');
     }
 
     foreach ($this->exactWordRules as $misspelling => $correction) {
       $this->checkExactWord($path, $misspelling, $correction);
     }
 
     foreach ($this->partialWordRules as $misspelling => $correction) {
       $this->checkPartialWord($path, $misspelling, $correction);
     }
   }
 
   private function checkExactWord($path, $word, $correction) {
     $text = $this->getData($path);
     $matches = array();
     $num_matches = preg_match_all(
       '#\b'.preg_quote($word, '#').'\b#i',
       $text,
       $matches,
       PREG_OFFSET_CAPTURE);
     if (!$num_matches) {
       return;
     }
     foreach ($matches[0] as $match) {
       $original = $match[0];
       $replacement = self::fixLetterCase($correction, $original);
       $this->raiseLintAtOffset(
         $match[1],
         self::LINT_SPELLING_EXACT,
         pht(
           "Possible spelling error. You wrote '%s', but did you mean '%s'?",
           $word,
           $correction),
         $original,
         $replacement);
     }
   }
 
   private function checkPartialWord($path, $word, $correction) {
     $text = $this->getData($path);
     $pos = 0;
     while ($pos < strlen($text)) {
       $next = stripos($text, $word, $pos);
       if ($next === false) {
         return;
       }
       $original = substr($text, $next, strlen($word));
       $replacement = self::fixLetterCase($correction, $original);
       $this->raiseLintAtOffset(
         $next,
         self::LINT_SPELLING_PARTIAL,
         pht(
           "Possible spelling error. You wrote '%s', but did you mean '%s'?",
           $word,
           $correction),
         $original,
         $replacement);
       $pos = $next + 1;
     }
   }
 
   public static function fixLetterCase($string, $case) {
     switch ($case) {
       case strtolower($case):
         return strtolower($string);
       case strtoupper($case):
         return strtoupper($string);
       case ucwords(strtolower($case)):
         return ucwords(strtolower($string));
       default:
         return null;
     }
   }
 
 }