Closure compilation: Modify compile_js2.py to not swallow errors.

third_party/closure_compiler/compile2.py

 #!/usr/bin/python
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Runs Closure compiler on JavaScript files to check for errors and produce
 minified output."""
 
 import argparse
 import os
@@ skipping 158 matching lines @@
     Args:
       sources: Files to check. sources[0] is the typically the target file.
           sources[1:] are externs and dependencies in topological order. Order
           is not guaranteed if custom_sources is True.
       out_file: A file where the compiled output is written to.
       closure_args: Arguments passed directly to the Closure compiler.
       custom_sources: Whether |sources| was customized by the target (e.g. not
           in GYP dependency order).
 
     Returns:
-      (found_errors, stderr) A boolean indicating whether errors were found and
-          the raw Closure compiler stderr (as a string).
+      (return_code, found_errors, stderr) The return code from the jar command,
+          a boolean indicating whether type checking related errors were found
+          and the raw Closure compiler stderr (as a string). Note that it is
+          possible for |found_errors| to be false, and |return_code| to be
+          non-zero, for example when wrong flags are passed to the compiler
+          (which yields an InvalidOptionsException)
     """
     is_extern = lambda f: 'externs' in f
     externs_and_deps = [self._POLYMER_EXTERNS]
 
     if custom_sources:
       if custom_includes:
         # TODO(dbeam): this is fairly hacky. Can we just remove custom_sources
         # soon when all the things kept on life support using it die?
         self._target = sources.pop()
       externs_and_deps += sources
@@ skipping 45 matching lines @@
       os.makedirs(out_dir)
 
     checks_only = 'checks_only' in closure_args
 
     if not checks_only:
       args += ["--js_output_file=%s" % out_file]
       args += ["--create_source_map=%s" % (self._MAP_FILE_FORMAT % out_file)]
 
     self._log_debug("Args: %s" % " ".join(args))
 
-    _, stderr = self.run_jar(self._compiler_jar, args)
+    return_code, stderr = self.run_jar(self._compiler_jar, args)
 
     errors = stderr.strip().split("\n\n")
     maybe_summary = errors.pop()
 
     summary = re.search("(?P<error_count>\d+).*error.*warning", maybe_summary)
     if summary:
       self._log_debug("Summary: %s" % maybe_summary)
     else:
       # Not a summary. Running the jar failed. Bail.
       self._log_error(stderr)
@@ skipping 16 matching lines @@
       errors = map(self._clean_up_error, errors)
       output = self._format_errors(errors)
 
       if errors:
         prefix = "\n" if output else ""
         self._log_error("Error in: %s%s%s" % (self._target, prefix, output))
       elif output:
         self._log_debug("Output: %s" % output)
 
     self._nuke_temp_files()
-    return bool(errors), stderr
+    return return_code, bool(errors), stderr

[dpapad, 2017/06/08 22:26:05]

An alternative to adding a new return variable, is to do something like

return bool(errors) or return_code > 0, stderr

Let me know if you think that's better (simpler, cleaner etc).

 
 
 if __name__ == "__main__":
   parser = argparse.ArgumentParser(
       description="Typecheck JavaScript using Closure compiler")
   parser.add_argument("sources", nargs=argparse.ONE_OR_MORE,
                       help="Path to a source file to typecheck")
   parser.add_argument("--custom_sources", action="store_true",
                       help="Whether this rules has custom sources.")
   parser.add_argument("--custom_includes", action="store_true",
                       help="If present, <include>s are processed when"
                            "using --custom_files.")
   parser.add_argument("-o", "--out_file", required=True,
                       help="A file where the compiled output is written to")
   parser.add_argument("-c", "--closure_args", nargs=argparse.ZERO_OR_MORE,
                       help="Arguments passed directly to the Closure compiler")
   parser.add_argument("-v", "--verbose", action="store_true",
                       help="Show more information as this script runs")
   opts = parser.parse_args()
 
   checker = Checker(verbose=opts.verbose)
 
-  found_errors, stderr = checker.check(opts.sources, out_file=opts.out_file,
-                                       closure_args=opts.closure_args,
-                                       custom_sources=opts.custom_sources,
-                                       custom_includes=opts.custom_includes)
+  return_code, found_errors, stderr = checker.check(
+      opts.sources, out_file=opts.out_file,
+      closure_args=opts.closure_args,
+      custom_sources=opts.custom_sources,
+      custom_includes=opts.custom_includes)
 
-  if found_errors:
+  if found_errors or return_code > 0 :
     if opts.custom_sources:
       print stderr
     sys.exit(1)