diff --git a/src/lint/linter/ArcanistCoffeeLintLinter.php b/src/lint/linter/ArcanistCoffeeLintLinter.php
index 3301356a..d744146a 100644
--- a/src/lint/linter/ArcanistCoffeeLintLinter.php
+++ b/src/lint/linter/ArcanistCoffeeLintLinter.php
@@ -1,139 +1,135 @@
 <?php
 
 final class ArcanistCoffeeLintLinter extends ArcanistExternalLinter {
 
   private $config;
 
   public function getInfoName() {
     return 'CoffeeLint';
   }
 
   public function getInfoURI() {
     return 'http://www.coffeelint.org';
   }
 
   public function getInfoDescription() {
     return pht(
       'CoffeeLint is a style checker that helps keep CoffeeScript '.
       'code clean and consistent.');
   }
 
   public function getLinterName() {
     return 'COFFEE';
   }
 
   public function getLinterConfigurationName() {
     return 'coffeelint';
   }
 
   public function getDefaultBinary() {
     return 'coffeelint';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+\.\d+)$/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht(
       'Install CoffeeLint using `%s`.',
       'npm install -g coffeelint');
   }
 
   protected function getMandatoryFlags() {
     $options = array(
       '--reporter=raw',
     );
 
     if ($this->config) {
       $options[] = '--file='.$this->config;
     }
 
     return $options;
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
       'coffeelint.config' => array(
         'type' => 'optional string',
         'help' => pht('A custom configuration file.'),
       ),
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'coffeelint.config':
         $this->config = $value;
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $messages = array();
     $output = phutil_json_decode($stdout);
 
     // We are only linting a single file.
     if (count($output) != 1) {
       return false;
     }
 
     foreach ($output as $reports) {
       foreach ($reports as $report) {
         // Column number is not provided in the output.
         // See https://github.com/clutchski/coffeelint/issues/87
 
         $message = id(new ArcanistLintMessage())
           ->setPath($path)
           ->setLine($report['lineNumber'])
           ->setCode($this->getLinterName())
           ->setName(ucwords(str_replace('_', ' ', $report['name'])))
           ->setDescription($report['message'])
           ->setOriginalText(idx($report, 'line'));
 
         switch ($report['level']) {
           case 'warn':
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_WARNING);
             break;
 
           case 'error':
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
             break;
 
           default:
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ADVICE);
             break;
         }
 
         $messages[] = $message;
       }
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     // NOTE: We can't figure out which rule generated each message, so we
     // can not customize severities.
     throw new Exception(
       pht(
         "CoffeeLint does not currently support custom severity levels, ".
         "because rules can't be identified from messages in output."));
   }
 
 }
diff --git a/src/lint/linter/ArcanistCpplintLinter.php b/src/lint/linter/ArcanistCpplintLinter.php
index f4a9123c..0680d474 100644
--- a/src/lint/linter/ArcanistCpplintLinter.php
+++ b/src/lint/linter/ArcanistCpplintLinter.php
@@ -1,80 +1,76 @@
 <?php
 
 /**
  * Uses Google's `cpplint.py` to check code.
  */
 final class ArcanistCpplintLinter extends ArcanistExternalLinter {
 
   public function getLinterName() {
     return 'CPPLINT';
   }
 
   public function getLinterConfigurationName() {
     return 'cpplint';
   }
 
   public function getDefaultBinary() {
     return 'cpplint';
   }
 
   public function getInstallInstructions() {
     return pht(
       'Install cpplint.py using `%s`.',
       'wget http://google-styleguide.googlecode.com'.
       '/svn/trunk/cpplint/cpplint.py');
   }
 
   protected function getDefaultMessageSeverity($code) {
     return ArcanistLintSeverity::SEVERITY_WARNING;
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = explode("\n", $stderr);
 
     $messages = array();
     foreach ($lines as $line) {
       $line = trim($line);
       $matches = null;
       $regex = '/^-:(\d+):\s*(.*)\s*\[(.*)\] \[(\d+)\]$/';
       if (!preg_match($regex, $line, $matches)) {
         continue;
       }
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
 
       $severity = $this->getLintMessageSeverity($matches[3]);
 
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[1]);
       $message->setCode($matches[3]);
       $message->setName($matches[3]);
       $message->setDescription($matches[2]);
       $message->setSeverity($severity);
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     if (!preg_match('@^[a-z_]+/[a-z_]+$@', $code)) {
       throw new Exception(
         pht(
           'Unrecognized lint message code "%s". Expected a valid cpplint '.
           'lint code like "%s" or "%s".',
           $code,
           'build/include_order',
           'whitespace/braces'));
     }
 
     return $code;
   }
 
 }
diff --git a/src/lint/linter/ArcanistExternalLinter.php b/src/lint/linter/ArcanistExternalLinter.php
index 83586081..c10cbfdc 100644
--- a/src/lint/linter/ArcanistExternalLinter.php
+++ b/src/lint/linter/ArcanistExternalLinter.php
@@ -1,471 +1,478 @@
 <?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->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 ($err && $this->shouldExpectCommandErrors() && !$messages) {
+      // We assume that if the future exits with a non-zero status and we
+      // failed to parse any linter messages, then something must've gone wrong
+      // during parsing.
+      $messages = false;
+    }
+
     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':
         $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();
 
         $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/ArcanistFlake8Linter.php b/src/lint/linter/ArcanistFlake8Linter.php
index dabc0b42..db8e9177 100644
--- a/src/lint/linter/ArcanistFlake8Linter.php
+++ b/src/lint/linter/ArcanistFlake8Linter.php
@@ -1,118 +1,114 @@
 <?php
 
 /**
  * Uses "flake8" to detect various errors in Python code.
  * Requires version 1.7.0 or newer of flake8.
  */
 final class ArcanistFlake8Linter extends ArcanistExternalLinter {
 
   public function getInfoName() {
     return 'Flake8';
   }
 
   public function getInfoURI() {
     return 'https://pypi.python.org/pypi/flake8';
   }
 
   public function getInfoDescription() {
     return pht(
       'Uses `%s` to run several linters (PyFlakes, pep8, and a McCabe '.
       'complexity checker) on Python source files.',
       'flake8');
   }
 
   public function getLinterName() {
     return 'flake8';
   }
 
   public function getLinterConfigurationName() {
     return 'flake8';
   }
 
   public function getDefaultBinary() {
     return 'flake8';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+(?:\.\d+)?)\b/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install flake8 using `%s`.', 'easy_install flake8');
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stdout, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       // stdin:2: W802 undefined name 'foo'  # pyflakes
       // stdin:3:1: E302 expected 2 blank lines, found 1  # pep8
       $regexp = '/^(.*?):(\d+):(?:(\d+):)? (\S+) (.*)$/';
       if (!preg_match($regexp, $line, $matches)) {
         continue;
       }
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
 
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[2]);
       if (!empty($matches[3])) {
         $message->setChar($matches[3]);
       }
       $message->setCode($matches[4]);
       $message->setName($this->getLinterName().' '.$matches[3]);
       $message->setDescription($matches[5]);
       $message->setSeverity($this->getLintMessageSeverity($matches[4]));
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function getDefaultMessageSeverity($code) {
     if (preg_match('/^C/', $code)) {
       // "C": Cyclomatic complexity
       return ArcanistLintSeverity::SEVERITY_ADVICE;
     } else if (preg_match('/^W/', $code)) {
       // "W": PEP8 Warning
       return ArcanistLintSeverity::SEVERITY_WARNING;
     } else {
       // "E": PEP8 Error
       // "F": PyFlakes Error
       return ArcanistLintSeverity::SEVERITY_ERROR;
     }
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     if (!preg_match('/^(E|W|C|F)\d+$/', $code)) {
       throw new Exception(
         pht(
           'Unrecognized lint message code "%s". Expected a valid flake8 '.
           'lint code like "%s", or "%s", or "%s", or "%s".',
           $code,
           'E225',
           'W291',
           'F811',
           'C901'));
     }
 
     return $code;
   }
 
 }
diff --git a/src/lint/linter/ArcanistJSONLintLinter.php b/src/lint/linter/ArcanistJSONLintLinter.php
index 2ac0dbbe..d6b13103 100644
--- a/src/lint/linter/ArcanistJSONLintLinter.php
+++ b/src/lint/linter/ArcanistJSONLintLinter.php
@@ -1,89 +1,85 @@
 <?php
 
 /**
  * A linter for JSON files.
  */
 final class ArcanistJSONLintLinter extends ArcanistExternalLinter {
 
   public function getInfoName() {
     return 'JSON Lint';
   }
 
   public function getInfoURI() {
     return 'https://github.com/zaach/jsonlint';
   }
 
   public function getInfoDescription() {
     return pht('Use `%s` to detect syntax errors in JSON files.', 'jsonlint');
   }
 
   public function getLinterName() {
     return 'JSON';
   }
 
   public function getLinterConfigurationName() {
     return 'jsonlint';
   }
 
   public function getDefaultBinary() {
     return 'jsonlint';
   }
 
   public function getVersion() {
     // NOTE: `jsonlint --version` returns a non-zero exit status.
     list($err, $stdout) = exec_manual(
       '%C --version',
       $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+\.\d+)$/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install jsonlint using `%s`.', 'npm install -g jsonlint');
   }
 
   protected function getMandatoryFlags() {
     return array(
       '--compact',
     );
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stderr, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       $match = preg_match(
         '/^(?:(?<path>.+): )?'.
         'line (?<line>\d+), col (?<column>\d+), '.
         '(?<description>.*)$/',
         $line,
         $matches);
 
       if ($match) {
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($matches['line']);
         $message->setChar($matches['column']);
         $message->setCode($this->getLinterName());
         $message->setDescription(ucfirst($matches['description']));
         $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
 
         $messages[] = $message;
       }
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
 }
diff --git a/src/lint/linter/ArcanistJscsLinter.php b/src/lint/linter/ArcanistJscsLinter.php
index 6d8f2537..d1c0b3c4 100644
--- a/src/lint/linter/ArcanistJscsLinter.php
+++ b/src/lint/linter/ArcanistJscsLinter.php
@@ -1,152 +1,148 @@
 <?php
 
 final class ArcanistJscsLinter extends ArcanistExternalLinter {
 
   private $config;
   private $preset;
 
   public function getInfoName() {
     return 'JSCS';
   }
 
   public function getInfoURI() {
     return 'https://github.com/mdevils/node-jscs';
   }
 
   public function getInfoDescription() {
     return pht(
       'Use `%s` to detect issues with Javascript source files.',
       'jscs');
   }
 
   public function getLinterName() {
     return 'JSCS';
   }
 
   public function getLinterConfigurationName() {
     return 'jscs';
   }
 
   public function getDefaultBinary() {
     return 'jscs';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^(?P<version>\d+\.\d+\.\d+)$/';
     if (preg_match($regex, $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install JSCS using `%s`.', 'npm install -g jscs');
   }
 
   protected function getMandatoryFlags() {
     $options = array();
 
     $options[] = '--reporter=checkstyle';
     $options[] = '--no-colors';
 
     if ($this->config) {
       $options[] = '--config='.$this->config;
     }
 
     if ($this->preset) {
       $options[] = '--preset='.$this->preset;
     }
 
     return $options;
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
       'jscs.config' => array(
         'type' => 'optional string',
         'help' => pht('Pass in a custom %s file path.', 'jscsrc'),
       ),
       'jscs.preset' => array(
         'type' => 'optional string',
         'help' => pht('Custom preset.'),
       ),
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'jscs.config':
         $this->config = $value;
         return;
 
       case 'jscs.preset':
         $this->preset = $value;
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $report_dom = new DOMDocument();
     $ok = @$report_dom->loadXML($stdout);
 
     if (!$ok) {
       return false;
     }
 
     $messages = array();
     foreach ($report_dom->getElementsByTagName('file') as $file) {
       foreach ($file->getElementsByTagName('error') as $error) {
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($error->getAttribute('line'));
         $message->setChar($error->getAttribute('column'));
         $message->setCode('JSCS');
         $message->setDescription($error->getAttribute('message'));
 
         switch ($error->getAttribute('severity')) {
           case 'error':
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
             break;
 
           case 'warning':
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_WARNING);
             break;
 
           default:
             $message->setSeverity(ArcanistLintSeverity::SEVERITY_ADVICE);
             break;
         }
 
         $messages[] = $message;
       }
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
 
     // NOTE: We can't figure out which rule generated each message, so we
     // can not customize severities.
     //
     // See https://github.com/mdevils/node-jscs/issues/224
 
     throw new Exception(
       pht(
         "JSCS does not currently support custom severity levels, because ".
         "rules can't be identified from messages in output."));
   }
 
 }
diff --git a/src/lint/linter/ArcanistLesscLinter.php b/src/lint/linter/ArcanistLesscLinter.php
index f51660e2..4032b1ed 100644
--- a/src/lint/linter/ArcanistLesscLinter.php
+++ b/src/lint/linter/ArcanistLesscLinter.php
@@ -1,187 +1,183 @@
 <?php
 
 /**
  * A linter for LESSCSS files.
  *
  * This linter uses [[https://github.com/less/less.js | lessc]] to detect
  * errors and potential problems in [[http://lesscss.org/ | LESS]] code.
  */
 final class ArcanistLesscLinter extends ArcanistExternalLinter {
 
   const LINT_RUNTIME_ERROR   = 1;
   const LINT_ARGUMENT_ERROR  = 2;
   const LINT_FILE_ERROR      = 3;
   const LINT_NAME_ERROR      = 4;
   const LINT_OPERATION_ERROR = 5;
   const LINT_PARSE_ERROR     = 6;
   const LINT_SYNTAX_ERROR    = 7;
 
   private $strictMath = false;
   private $strictUnits = false;
 
   public function getInfoName() {
     return 'Less';
   }
 
   public function getInfoURI() {
     return 'https://lesscss.org/';
   }
 
   public function getInfoDescription() {
     return pht(
       'Use the `%s` mode provided by `%s` to detect errors in '.
       'Less source files.',
       '--lint',
       'lessc');
   }
 
   public function getLinterName() {
     return 'LESSC';
   }
 
   public function getLinterConfigurationName() {
     return 'lessc';
   }
 
   public function getLinterConfigurationOptions() {
     return parent::getLinterConfigurationOptions() + array(
       'lessc.strict-math' => array(
         'type' => 'optional bool',
         'help' => pht(
           'Enable strict math, which only processes mathematical expressions '.
           'inside extraneous parentheses.'),
       ),
       'lessc.strict-units' => array(
         'type' => 'optional bool',
         'help' => pht('Enable strict handling of units in expressions.'),
       ),
     );
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'lessc.strict-math':
         $this->strictMath = $value;
         return;
       case 'lessc.strict-units':
         $this->strictUnits = $value;
         return;
     }
 
     return parent::setLinterConfigurationValue($key, $value);
   }
 
   public function getLintNameMap() {
     return array(
       self::LINT_RUNTIME_ERROR   => pht('Runtime Error'),
       self::LINT_ARGUMENT_ERROR  => pht('Argument Error'),
       self::LINT_FILE_ERROR      => pht('File Error'),
       self::LINT_NAME_ERROR      => pht('Name Error'),
       self::LINT_OPERATION_ERROR => pht('Operation Error'),
       self::LINT_PARSE_ERROR     => pht('Parse Error'),
       self::LINT_SYNTAX_ERROR    => pht('Syntax Error'),
     );
   }
 
   public function getDefaultBinary() {
     return 'lessc';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^lessc (?P<version>\d+\.\d+\.\d+)\b/';
     if (preg_match($regex, $stdout, $matches)) {
       $version = $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install lessc using `%s`.', 'npm install -g less');
   }
 
   protected function getMandatoryFlags() {
     return array(
       '--lint',
       '--no-color',
       '--strict-math='.($this->strictMath ? 'on' : 'off'),
       '--strict-units='.($this->strictUnits ? 'on' : 'off'),
     );
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stderr, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       $match = preg_match(
         '/^(?P<name>\w+): (?P<description>.+) '.
         'in (?P<path>.+|-) '.
         'on line (?P<line>\d+), column (?P<column>\d+):$/',
         $line,
         $matches);
 
       if ($match) {
         switch ($matches['name']) {
           case 'RuntimeError':
             $code = self::LINT_RUNTIME_ERROR;
             break;
 
           case 'ArgumentError':
             $code = self::LINT_ARGUMENT_ERROR;
             break;
 
           case 'FileError':
             $code = self::LINT_FILE_ERROR;
             break;
 
           case 'NameError':
             $code = self::LINT_NAME_ERROR;
             break;
 
           case 'OperationError':
             $code = self::LINT_OPERATION_ERROR;
             break;
 
           case 'ParseError':
             $code = self::LINT_PARSE_ERROR;
             break;
 
           case 'SyntaxError':
             $code = self::LINT_SYNTAX_ERROR;
             break;
 
           default:
             throw new RuntimeException(
               pht(
                 'Unrecognized lint message code "%s".',
                 $code));
         }
 
         $code = $this->getLintCodeFromLinterConfigurationKey($matches['name']);
 
         $message = new ArcanistLintMessage();
         $message->setPath($path);
         $message->setLine($matches['line']);
         $message->setChar($matches['column']);
         $message->setCode($this->getLintMessageFullCode($code));
         $message->setSeverity($this->getLintMessageSeverity($code));
         $message->setName($this->getLintMessageName($code));
         $message->setDescription(ucfirst($matches['description']));
 
         $messages[] = $message;
       }
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
 }
diff --git a/src/lint/linter/ArcanistPEP8Linter.php b/src/lint/linter/ArcanistPEP8Linter.php
index a021ba83..f1cb21ee 100644
--- a/src/lint/linter/ArcanistPEP8Linter.php
+++ b/src/lint/linter/ArcanistPEP8Linter.php
@@ -1,102 +1,98 @@
 <?php
 
 /**
  * Uses "pep8.py" to enforce PEP8 rules for Python.
  */
 final class ArcanistPEP8Linter extends ArcanistExternalLinter {
 
   public function getInfoName() {
     return 'pep8';
   }
 
   public function getInfoURI() {
     return 'https://pypi.python.org/pypi/pep8';
   }
 
   public function getInfoDescription() {
     return pht(
       'pep8 is a tool to check your Python code against some of the '.
       'style conventions in PEP 8.');
   }
 
   public function getLinterName() {
     return 'PEP8';
   }
 
   public function getLinterConfigurationName() {
     return 'pep8';
   }
 
   public function getDefaultBinary() {
     return 'pep8';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+(?:\.\d+)?)\b/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install PEP8 using `%s`.', 'easy_install pep8');
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stdout, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       if (!preg_match('/^(.*?):(\d+):(\d+): (\S+) (.*)$/', $line, $matches)) {
         continue;
       }
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[2]);
       $message->setChar($matches[3]);
       $message->setCode($matches[4]);
       $message->setName('PEP8 '.$matches[4]);
       $message->setDescription($matches[5]);
       $message->setSeverity($this->getLintMessageSeverity($matches[4]));
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function getDefaultMessageSeverity($code) {
     if (preg_match('/^W/', $code)) {
       return ArcanistLintSeverity::SEVERITY_WARNING;
     } else {
       return ArcanistLintSeverity::SEVERITY_ERROR;
     }
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     if (!preg_match('/^(E|W)\d+$/', $code)) {
       throw new Exception(
         pht(
           'Unrecognized lint message code "%s". Expected a valid PEP8 '.
           'lint code like "%s" or "%s".',
           $code,
           'E101',
           'W291'));
     }
 
     return $code;
   }
 
 }
diff --git a/src/lint/linter/ArcanistPuppetLintLinter.php b/src/lint/linter/ArcanistPuppetLintLinter.php
index ea5b66cf..8336cd42 100644
--- a/src/lint/linter/ArcanistPuppetLintLinter.php
+++ b/src/lint/linter/ArcanistPuppetLintLinter.php
@@ -1,143 +1,139 @@
 <?php
 
 /**
  * A linter for Puppet files.
  */
 final class ArcanistPuppetLintLinter extends ArcanistExternalLinter {
 
   private $config;
 
   public function getInfoName() {
     return 'puppet-lint';
   }
 
   public function getInfoURI() {
     return 'http://puppet-lint.com/';
   }
 
   public function getInfoDescription() {
     return pht(
       'Use `%s` to check that your Puppet manifests '.
       'conform to the style guide.',
       'puppet-lint');
   }
 
   public function getLinterName() {
     return 'PUPPETLINT';
   }
 
   public function getLinterConfigurationName() {
     return 'puppet-lint';
   }
 
   public function getDefaultBinary() {
     return 'puppet-lint';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^puppet-lint (?P<version>\d+\.\d+\.\d+)$/';
     if (preg_match($regex, $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht(
       'Install puppet-lint using `%s`.',
       'gem install puppet-lint');
   }
 
   protected function getMandatoryFlags() {
     return array(
       '--error-level=all',
       sprintf('--log-format=%s', implode('|', array(
         '%{linenumber}',
         '%{column}',
         '%{kind}',
         '%{check}',
         '%{message}',
       ))),
     );
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
       'puppet-lint.config' => array(
         'type' => 'optional string',
         'help' => pht('Pass in a custom configuration file path.'),
       ),
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'puppet-lint.config':
         $this->config = $value;
         return;
 
       default:
         return parent::setLinterConfigurationValue($key, $value);
     }
   }
 
   protected function getDefaultFlags() {
     $options = array();
 
     if ($this->config) {
       $options[] = '--config='.$this->config;
     }
 
     return $options;
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stdout, false);
     $messages = array();
 
     foreach ($lines as $line) {
       $matches = explode('|', $line, 5);
 
       if (count($matches) < 5) {
         continue;
       }
 
       $message = id(new ArcanistLintMessage())
         ->setPath($path)
         ->setLine($matches[0])
         ->setChar($matches[1])
         ->setCode($this->getLinterName())
         ->setName(ucwords(str_replace('_', ' ', $matches[3])))
         ->setDescription(ucfirst($matches[4]));
 
       switch ($matches[2]) {
         case 'warning':
           $message->setSeverity(ArcanistLintSeverity::SEVERITY_WARNING);
           break;
 
         case 'error':
           $message->setSeverity(ArcanistLintSeverity::SEVERITY_ERROR);
           break;
 
         default:
           $message->setSeverity(ArcanistLintSeverity::SEVERITY_ADVICE);
           break;
       }
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
 }
diff --git a/src/lint/linter/ArcanistPyFlakesLinter.php b/src/lint/linter/ArcanistPyFlakesLinter.php
index 11ede0c3..3a79e02e 100644
--- a/src/lint/linter/ArcanistPyFlakesLinter.php
+++ b/src/lint/linter/ArcanistPyFlakesLinter.php
@@ -1,91 +1,87 @@
 <?php
 
 /**
  * Uses "PyFlakes" to detect various errors in Python code.
  */
 final class ArcanistPyFlakesLinter extends ArcanistExternalLinter {
 
   public function getInfoURI() {
     return 'https://pypi.python.org/pypi/pyflakes';
   }
 
   public function getInfoName() {
     return pht('PyFlakes');
   }
 
   public function getInfoDescription() {
     return pht(
       'PyFlakes is a simple program which checks Python source files for '.
       'errors.');
   }
 
   public function getLinterName() {
     return 'PYFLAKES';
   }
 
   public function getLinterConfigurationName() {
     return 'pyflakes';
   }
 
   public function getDefaultBinary() {
     return 'pyflakes';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     if (preg_match('/^(?P<version>\d+\.\d+\.\d+)$/', $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install pyflakes with `%s`.', 'pip install pyflakes');
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stdout, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
       if (!preg_match('/^(.*?):(\d+): (.*)$/', $line, $matches)) {
         continue;
       }
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
 
       $severity = ArcanistLintSeverity::SEVERITY_WARNING;
       $description = $matches[3];
 
       $error_regexp = '/(^undefined|^duplicate|before assignment$)/';
       if (preg_match($error_regexp, $description)) {
         $severity = ArcanistLintSeverity::SEVERITY_ERROR;
       }
 
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[2]);
       $message->setCode($this->getLinterName());
       $message->setDescription($description);
       $message->setSeverity($severity);
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function canCustomizeLintSeverities() {
     return false;
   }
 
 }
diff --git a/src/lint/linter/ArcanistPyLintLinter.php b/src/lint/linter/ArcanistPyLintLinter.php
index 46be2f45..111cc27e 100644
--- a/src/lint/linter/ArcanistPyLintLinter.php
+++ b/src/lint/linter/ArcanistPyLintLinter.php
@@ -1,182 +1,178 @@
 <?php
 
 /**
  * Uses "PyLint" to detect various errors in Python code.
  */
 final class ArcanistPyLintLinter extends ArcanistExternalLinter {
 
   private $config;
 
   public function getInfoName() {
     return 'PyLint';
   }
 
   public function getInfoURI() {
     return 'http://www.pylint.org/';
   }
 
   public function getInfoDescription() {
     return pht(
       'PyLint is a Python source code analyzer which looks for '.
       'programming errors, helps enforcing a coding standard and '.
       'sniffs for some code smells.');
   }
 
   public function getLinterName() {
     return 'PyLint';
   }
 
   public function getLinterConfigurationName() {
     return 'pylint';
   }
 
   public function getDefaultBinary() {
     return 'pylint';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^pylint (?P<version>\d+\.\d+\.\d+),/';
     if (preg_match($regex, $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht(
       'Install PyLint using `%s`.',
       'pip install pylint');
   }
 
   public function shouldExpectCommandErrors() {
     return true;
   }
 
   public function getLinterConfigurationOptions() {
     $options = array(
       'pylint.config' => array(
         'type' => 'optional string',
         'help' => pht('Pass in a custom configuration file path.'),
       ),
     );
 
     return $options + parent::getLinterConfigurationOptions();
   }
 
   public function setLinterConfigurationValue($key, $value) {
     switch ($key) {
       case 'pylint.config':
         $this->config = $value;
         return;
 
       default:
         return parent::setLinterConfigurationValue($key, $value);
     }
   }
 
   protected function getMandatoryFlags() {
     $options = array();
 
     $options[] = '--reports=no';
     $options[] = '--msg-template="{line}|{column}|{msg_id}|{symbol}|{msg}"';
 
     // Specify an `--rcfile`, either absolute or relative to the project root.
     // Stupidly, the command line args above are overridden by rcfile, so be
     // careful.
     $config = $this->config;
     if ($config !== null) {
       $options[] = '--rcfile='.$config;
     }
 
     return $options;
   }
 
   protected function getDefaultFlags() {
     $options = array();
 
     $installed_version = $this->getVersion();
     $minimum_version = '1.0.0';
     if (version_compare($installed_version, $minimum_version, '<')) {
       throw new ArcanistMissingLinterException(
         pht(
           '%s is not compatible with the installed version of pylint. '.
           'Minimum version: %s; installed version: %s.',
           __CLASS__,
           $minimum_version,
           $installed_version));
     }
 
     return $options;
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     if ($err === 32) {
       // According to `man pylint` the exit status of 32 means there was a
       // usage error. That's bad, so actually exit abnormally.
       return false;
     }
 
     $lines = phutil_split_lines($stdout, false);
     $messages = array();
 
     foreach ($lines as $line) {
       $matches = explode('|', $line, 5);
 
       if (count($matches) < 5) {
         continue;
       }
 
       $message = id(new ArcanistLintMessage())
         ->setPath($path)
         ->setLine($matches[0])
         ->setChar($matches[1])
         ->setCode($matches[2])
         ->setSeverity($this->getLintMessageSeverity($matches[2]))
         ->setName(ucwords(str_replace('-', ' ', $matches[3])))
         ->setDescription($matches[4]);
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
   protected function getDefaultMessageSeverity($code) {
     switch (substr($code, 0, 1)) {
       case 'R':
       case 'C':
         return ArcanistLintSeverity::SEVERITY_ADVICE;
       case 'W':
         return ArcanistLintSeverity::SEVERITY_WARNING;
       case 'E':
       case 'F':
         return ArcanistLintSeverity::SEVERITY_ERROR;
       default:
         return ArcanistLintSeverity::SEVERITY_DISABLED;
     }
   }
 
   protected function getLintCodeFromLinterConfigurationKey($code) {
     if (!preg_match('/^(R|C|W|E|F)\d{4}$/', $code)) {
       throw new Exception(
         pht(
           'Unrecognized lint message code "%s". Expected a valid Pylint '.
           'lint code like "%s", or "%s", or "%s".',
           $code,
           'C0111',
           'E0602',
           'W0611'));
     }
 
     return $code;
   }
 
 }
diff --git a/src/lint/linter/ArcanistRubyLinter.php b/src/lint/linter/ArcanistRubyLinter.php
index 3a9845d4..bb29f381 100644
--- a/src/lint/linter/ArcanistRubyLinter.php
+++ b/src/lint/linter/ArcanistRubyLinter.php
@@ -1,91 +1,87 @@
 <?php
 
 /**
  * Uses `ruby` to detect various errors in Ruby code.
  */
 final class ArcanistRubyLinter extends ArcanistExternalLinter {
 
   public function getInfoURI() {
     return 'https://www.ruby-lang.org/';
   }
 
   public function getInfoName() {
     return pht('Ruby');
   }
 
   public function getInfoDescription() {
     return pht(
       'Use `%s` to check for syntax errors in Ruby source files.',
       'ruby');
   }
 
   public function getLinterName() {
     return 'RUBY';
   }
 
   public function getLinterConfigurationName() {
     return 'ruby';
   }
 
   public function getDefaultBinary() {
     return 'ruby';
   }
 
   public function getVersion() {
     list($stdout) = execx('%C --version', $this->getExecutableCommand());
 
     $matches = array();
     $regex = '/^ruby (?P<version>\d+\.\d+\.\d+)p\d+/';
     if (preg_match($regex, $stdout, $matches)) {
       return $matches['version'];
     } else {
       return false;
     }
   }
 
   public function getInstallInstructions() {
     return pht('Install `%s` from <%s>.', 'ruby', 'http://www.ruby-lang.org/');
   }
 
   protected function getMandatoryFlags() {
     // -w: turn on warnings
     // -c: check syntax
     return array('-w', '-c');
   }
 
   protected function parseLinterOutput($path, $err, $stdout, $stderr) {
     $lines = phutil_split_lines($stderr, false);
 
     $messages = array();
     foreach ($lines as $line) {
       $matches = null;
 
       if (!preg_match('/(.*?):(\d+): (.*?)$/', $line, $matches)) {
         continue;
       }
 
       foreach ($matches as $key => $match) {
         $matches[$key] = trim($match);
       }
 
       $code = head(explode(',', $matches[3]));
 
       $message = new ArcanistLintMessage();
       $message->setPath($path);
       $message->setLine($matches[2]);
       $message->setCode($this->getLinterName());
       $message->setName(pht('Syntax Error'));
       $message->setDescription($matches[3]);
       $message->setSeverity($this->getLintMessageSeverity($code));
 
       $messages[] = $message;
     }
 
-    if ($err && !$messages) {
-      return false;
-    }
-
     return $messages;
   }
 
 }