Remove Chromium's custom closure runner.

third_party/closure_compiler/compile.py

 #!/usr/bin/python
 # Copyright 2014 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 22 matching lines @@
     "-XX:+TieredCompilation"
   ]
 
   _MAP_FILE_FORMAT = "%s.map"
 
   def __init__(self, verbose=False):
     """
     Args:
       verbose: Whether this class should output diagnostic messages.
     """
-    self._runner_jar = os.path.join(_CURRENT_DIR, "runner", "runner.jar")
+    self._compiler_jar = os.path.join(_CURRENT_DIR, "compiler", "compiler.jar")
     self._temp_files = []
     self._verbose = verbose
     self._error_filter = error_filter.PromiseErrorFilter()
 
   def _nuke_temp_files(self):
     """Deletes any temp files this class knows about."""
     if not self._temp_files:
       return
 
     self._log_debug("Deleting temp files: %s" % ", ".join(self._temp_files))
@@ skipping 123 matching lines @@
 
     Return:
       The filepath of the newly created, written, and closed temporary file.
     """
     with tempfile.NamedTemporaryFile(mode="wt", delete=False) as tmp_file:
       self._temp_files.append(tmp_file.name)
       tmp_file.write(contents)
     return tmp_file.name
 
   def _run_js_check(self, sources, out_file=None, externs=None,
-                    runner_args=None, closure_args=None):
+                    closure_args=None):
     """Check |sources| for type errors.
 
     Args:
       sources: Files to check.
       out_file: A file where the compiled output is written to.
       externs: @extern files that inform the compiler about custom globals.
-      runner_args: Arguments passed to runner.jar.
       closure_args: Arguments passed directly to the Closure compiler.
 
     Returns:
       (errors, stderr) A parsed list of errors (strings) found by the compiler
           and the raw stderr (as a string).
     """
     args = ["--js=%s" % s for s in sources]
 
     if out_file:
       out_dir = os.path.dirname(out_file)
       if not os.path.exists(out_dir):
         os.makedirs(out_dir)
       args += ["--js_output_file=%s" % out_file]
       args += ["--create_source_map=%s" % (self._MAP_FILE_FORMAT % out_file)]
 
     args += ["--externs=%s" % e for e in externs or []]
 
     closure_args = closure_args or []
-    closure_args += ["summary_detail_level=3"]
+    closure_args += ["summary_detail_level=3", "continue_after_errors"]
     args += ["--%s" % arg for arg in closure_args]
 
-    args_file_content = " %s" % " ".join(args)
-    self._log_debug("Args: %s" % args_file_content.strip())
+    self._log_debug("Args: %s" % " ".join(args))
 
-    args_file = self._create_temp_file(args_file_content)
-    self._log_debug("Args file: %s" % args_file)
-
-    processed_runner_args = ["--%s" % arg for arg in runner_args or []]
-    processed_runner_args += ["--compiler-args-file=%s" % args_file]
-    _, stderr = self._run_jar(self._runner_jar, processed_runner_args)
+    _, stderr = self._run_jar(self._compiler_jar, args)
 
     errors = stderr.strip().split("\n\n")
     maybe_summary = errors.pop()
 
     if re.search(".*error.*warning.*typed", maybe_summary):
       self._log_debug("Summary: %s" % maybe_summary)
     else:
       # Not a summary. Running the jar failed. Bail.
       self._log_error(stderr)
       self._nuke_temp_files()
       sys.exit(1)
 
     if errors and out_file:
       if os.path.exists(out_file):
         os.remove(out_file)
       if os.path.exists(self._MAP_FILE_FORMAT % out_file):
         os.remove(self._MAP_FILE_FORMAT % out_file)
 
     return errors, stderr
 
   def check(self, source_file, out_file=None, depends=None, externs=None,
-            runner_args=None, closure_args=None):
+            closure_args=None):
     """Closure compiler |source_file| while checking for errors.
 
     Args:
       source_file: A file to check.
       out_file: A file where the compiled output is written to.
       depends: Files that |source_file| requires to run (e.g. earlier <script>).
       externs: @extern files that inform the compiler about custom globals.
-      runner_args: Arguments passed to runner.jar.
       closure_args: Arguments passed directly to the Closure compiler.
 
     Returns:
       (found_errors, stderr) A boolean indicating whether errors were found and
           the raw Closure compiler stderr (as a string).
     """
     self._log_debug("FILE: %s" % source_file)
 
     if source_file.endswith("_externs.js"):
       self._log_debug("Skipping externs: %s" % source_file)
       return
 
     self._file_arg = source_file
 
     cwd, tmp_dir = os.getcwd(), tempfile.gettempdir()
     rel_path = lambda f: os.path.join(os.path.relpath(cwd, tmp_dir), f)
 
     depends = depends or []
     includes = [rel_path(f) for f in depends + [source_file]]
     contents = ['<include src="%s">' % i for i in includes]
     meta_file = self._create_temp_file("\n".join(contents))
     self._log_debug("Meta file: %s" % meta_file)
 
     self._processor = processor.Processor(meta_file)
     self._expanded_file = self._create_temp_file(self._processor.contents)
     self._log_debug("Expanded file: %s" % self._expanded_file)
 
     errors, stderr = self._run_js_check([self._expanded_file],
                                         out_file=out_file, externs=externs,
-                                        runner_args=runner_args,
                                         closure_args=closure_args)
     filtered_errors = self._filter_errors(errors)
     cleaned_errors = map(self._clean_up_error, filtered_errors)
     output = self._format_errors(cleaned_errors)
 
     if cleaned_errors:
       prefix = "\n" if output else ""
       self._log_error("Error in: %s%s%s" % (source_file, prefix, output))
     elif output:
       self._log_debug("Output: %s" % output)
 
     self._nuke_temp_files()
     return bool(cleaned_errors), stderr
 
   def check_multiple(self, sources, out_file=None, externs=None,
-                     runner_args=None, closure_args=None):
+                     closure_args=None):
     """Closure compile a set of files and check for errors.
 
     Args:
       sources: An array of files to check.
       out_file: A file where the compiled output is written to.
       externs: @extern files that inform the compiler about custom globals.
-      runner_args: Arguments passed to runner.jar.
       closure_args: Arguments passed directly to the Closure compiler.
 
     Returns:
       (found_errors, stderr) A boolean indicating whether errors were found and
           the raw Closure Compiler stderr (as a string).
     """
     errors, stderr = self._run_js_check(sources, out_file=out_file,
                                         externs=externs,
-                                        runner_args=runner_args,
                                         closure_args=closure_args)
     self._nuke_temp_files()
     return bool(errors), stderr
 
 
 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")
   single_file_group = parser.add_mutually_exclusive_group()
   single_file_group.add_argument("--single_file", dest="single_file",
                                  action="store_true",
                                  help="Process each source file individually")
   # TODO(twellington): remove --no_single_file and use len(opts.sources).
   single_file_group.add_argument("--no_single_file", dest="single_file",
                                  action="store_false",
                                  help="Process all source files as a group")
   parser.add_argument("-d", "--depends", nargs=argparse.ZERO_OR_MORE)
   parser.add_argument("-e", "--externs", nargs=argparse.ZERO_OR_MORE)
   parser.add_argument("-o", "--out_file",
                       help="A file where the compiled output is written to")
-  parser.add_argument("-r", "--runner_args", nargs=argparse.ZERO_OR_MORE,
-                      help="Arguments passed to runner.jar")
   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")
 
   parser.set_defaults(single_file=True)
   opts = parser.parse_args()
 
   depends = opts.depends or []
   # TODO(devlin): should we run normpath() on this first and/or do this for
   # depends as well?
   externs = set(opts.externs or [])
   sources = set(opts.sources)
 
   externs.add(os.path.join(_CURRENT_DIR, "externs", "polymer-1.0.js"))
 
   checker = Checker(verbose=opts.verbose)
   if opts.single_file:
     for source in sources:
       # Normalize source to the current directory.
       source = os.path.normpath(os.path.join(os.getcwd(), source))
       depends, externs = build.inputs.resolve_recursive_dependencies(
           source, depends, externs)
 
       found_errors, _ = checker.check(source, out_file=opts.out_file,
                                       depends=depends, externs=externs,
-                                      runner_args=opts.runner_args,
                                       closure_args=opts.closure_args)
       if found_errors:
         sys.exit(1)
   else:
     found_errors, stderr = checker.check_multiple(
         sources,
         out_file=opts.out_file,
         externs=externs,
-        runner_args=opts.runner_args,
         closure_args=opts.closure_args)
     if found_errors:
       print stderr
       sys.exit(1)