Refactor compile_js.gypi to support script_args and closure_args

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
 import re
 import subprocess
 import sys
 import tempfile
 
 import build.inputs
 import processor
 import error_filter
 
 
 _CURRENT_DIR = os.path.join(os.path.dirname(__file__))
 
 
 class Checker(object):
   """Runs the Closure compiler on given source files to typecheck them
   and produce minified output."""
 
-  _COMMON_JSCOMP_ERRORS = [
-    "accessControls",
-    "ambiguousFunctionDecl",
-    "checkStructDictInheritance",
-    "checkTypes",
-    "checkVars",
-    "constantProperty",
-    "deprecated",
-    "externsValidation",
-    "globalThis",
-    "invalidCasts",
-    "missingProperties",
-    "missingReturn",
-    "nonStandardJsDocs",
-    "suspiciousCode",
-    "undefinedNames",
-    "undefinedVars",
-    "unknownDefines",
-    "uselessCode",
-    "visibility",
-  ]
-
-  # Extra @jsDocAnnotations used when compiling polymer code.
-  _POLYMER_EXTRA_ANNOTATIONS = [
-    "attribute",
-    "status",
-    "element",
-    "homepage",
-    "submodule",
-    "group",
-  ]
-
-  _COMMON_CLOSURE_ARGS = [
-    "--accept_const_keyword",
-    "--language_in=ECMASCRIPT5_STRICT",
-    "--summary_detail_level=3",
-    "--compilation_level=SIMPLE_OPTIMIZATIONS",
-    "--source_map_format=V3",
-    "--polymer_pass",
-  ] + [
-    "--jscomp_error=%s" % err for err in _COMMON_JSCOMP_ERRORS
-  ] + [
-    "--extra_annotation_name=%s" % a for a in _POLYMER_EXTRA_ANNOTATIONS
-  ]
-
-  # These are the extra flags used when compiling in strict mode.
-  # Flags that are normally disabled are turned on for strict mode.
-  _STRICT_CLOSURE_ARGS = [
-    "--jscomp_error=reportUnknownTypes",
-    "--jscomp_error=duplicate",
-    "--jscomp_error=misplacedTypeAnnotation",
-  ]
-
-  _DISABLED_CLOSURE_ARGS = [
-    # TODO(dbeam): happens when the same file is <include>d multiple times.
-    "--jscomp_off=duplicate",
-    # TODO(fukino): happens when cr.defineProperty() has a type annotation.
-    # Avoiding parse-time warnings needs 2 pass compiling. crbug.com/421562.
-    "--jscomp_off=misplacedTypeAnnotation",
-  ]
-
   _JAR_COMMAND = [
     "java",
     "-jar",
     "-Xms1024m",
     "-client",
     "-XX:+TieredCompilation"
   ]
 
   _MAP_FILE_FORMAT = "%s.map"
 
@@ skipping 29 matching lines @@
       print "(INFO) %s" % msg
 
   def _log_error(self, msg):
     """Logs |msg| to stderr regardless of --flags.
 
     Args:
       msg: An error message to log.
     """
     print >> sys.stderr, "(ERROR) %s" % msg
 
-  def _common_args(self):
-    """Returns an array of the common closure compiler args."""
-    if self._strict:
-      return self._COMMON_CLOSURE_ARGS + self._STRICT_CLOSURE_ARGS
-    return self._COMMON_CLOSURE_ARGS + self._DISABLED_CLOSURE_ARGS
-
   def _run_jar(self, jar, args):
     """Runs a .jar from the command line with arguments.
 
     Args:
       jar: A file path to a .jar file
       args: A list of command line arguments to be passed when running the .jar.
 
     Return:
       (exit_code, stderr) The exit code of the command (e.g. 0 for success) and
           the stderr collected while running |jar| (as a string).
@@ skipping 92 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,
-                    output_wrapper=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.
-      output_wrapper: Wraps output into this string at the place denoted by the
-          marker token %output%.
+      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)]
 
     if externs:
       args += ["--externs=%s" % e for e in externs]
 
-    if output_wrapper:
-      args += ['--output_wrapper="%s"' % output_wrapper]
+    if closure_args:
+      args += ["--%s" % arg for arg in closure_args]
 
-    args_file_content = " %s" % " ".join(self._common_args() + args)
+    args_file_content = " %s" % " ".join(args)
     self._log_debug("Args: %s" % args_file_content.strip())
 
     args_file = self._create_temp_file(args_file_content)
     self._log_debug("Args file: %s" % args_file)
 
     runner_args = ["--compiler-args-file=%s" % args_file]
     _, stderr = self._run_jar(self._runner_jar, runner_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,
-            output_wrapper=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.
-      output_wrapper: Wraps output into this string at the place denoted by the
-          marker token %output%.
+      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,
-                                        output_wrapper=output_wrapper)
+                                        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, output_wrapper=None,
-                     externs=None):
+  def check_multiple(self, sources, out_file=None, externs=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.
-      output_wrapper: Wraps output into this string at the place denoted by the
-          marker token %output%.
       externs: @extern files that inform the compiler about custom globals.
+      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,
-                                        output_wrapper=output_wrapper,
-                                        externs=externs)
+                                        externs=externs,
+                                        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",
+  parser.add_argument("-o", "--out-file", dest="out_file",
                       help="A file where the compiled output is written to")
-  parser.add_argument("-w", "--output_wrapper",
-                      help="Wraps output into this string at the place"
-                         + " denoted by the marker token %output%")
+  parser.add_argument("-c", "--closure-args", dest="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.add_argument("--strict", action="store_true",
-                      help="Enable strict type checking")
-  parser.add_argument("--success-stamp",
-                      help="Timestamp file to update upon success")
 
   parser.set_defaults(single_file=True, strict=False)
   opts = parser.parse_args()
 
   depends = opts.depends or []
   externs = set(opts.externs or [])
 
   polymer_externs = os.path.join(os.path.dirname(_CURRENT_DIR), 'polymer',
                                  'v1_0', 'components-chromium',
                                  'polymer-externs', 'polymer.externs.js')
   externs.add(polymer_externs)
 
   checker = Checker(verbose=opts.verbose, strict=opts.strict)
   if opts.single_file:
     for source in opts.sources:
       depends, externs = build.inputs.resolve_recursive_dependencies(
           source, depends, externs)
       found_errors, _ = checker.check(source, out_file=opts.out_file,
                                       depends=depends, externs=externs,
-                                      output_wrapper=opts.output_wrapper)
+                                      closure_args=opts.closure_args)
       if found_errors:
         sys.exit(1)
   else:
     found_errors, stderr = checker.check_multiple(
         opts.sources,
         out_file=opts.out_file,
-        output_wrapper=opts.output_wrapper,
-        externs=externs)
+        externs=externs,
+        closure_args=opts.closure_args)
     if found_errors:
       print stderr
       sys.exit(1)
-
-  if opts.success_stamp:
-    with open(opts.success_stamp, "w"):
-      os.utime(opts.success_stamp, None)