Add a flag to the compiler for compiling polymer code.

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__))

[Dan Beam, 2015/05/12 04:22:37]

_CURRENT_DIR

[Jeremy Klein, 2015/05/12 04:47:49]

Done.

+
 
 class Checker(object):
   """Runs the Closure compiler on given source files to typecheck them
   and produce minified output."""
 
+  _COMMON_JSCOMP_ERROR = [

[Dan Beam, 2015/05/12 04:22:37]

I don't think you really need _COMMON unless there's another list of errors...,
also _JSCOMP_ERRORS (<-- S)?

[Jeremy Klein, 2015/05/12 04:47:49]

There are a few in _STRICT_CLOSURE_ARGS.

Worth doing the list comprehension there too?

+    "accessControls",
+    "ambiguousFunctionDecl",
+    "checkStructDictInheritance",
+    "checkTypes",
+    "checkVars",
+    "constantProperty",
+    "deprecated",
+    "externsValidation",
+    "globalThis",
+    "invalidCasts",
+    "missingProperties",
+    "missingReturn",
+    "nonStandardJsDocs",
+    "suspiciousCode",
+    "undefinedNames",
+    "undefinedVars",
+    "unknownDefines",
+    "uselessCode",
+    "visibility",
+  ]
+
   _COMMON_CLOSURE_ARGS = [
     "--accept_const_keyword",
-    "--jscomp_error=accessControls",
-    "--jscomp_error=ambiguousFunctionDecl",
-    "--jscomp_error=checkStructDictInheritance",
-    "--jscomp_error=checkTypes",
-    "--jscomp_error=checkVars",
-    "--jscomp_error=constantProperty",
-    "--jscomp_error=deprecated",
-    "--jscomp_error=externsValidation",
-    "--jscomp_error=globalThis",
-    "--jscomp_error=invalidCasts",
-    "--jscomp_error=missingProperties",
-    "--jscomp_error=missingReturn",
-    "--jscomp_error=nonStandardJsDocs",
-    "--jscomp_error=suspiciousCode",
-    "--jscomp_error=undefinedNames",
-    "--jscomp_error=undefinedVars",
-    "--jscomp_error=unknownDefines",
-    "--jscomp_error=uselessCode",
-    "--jscomp_error=visibility",
     "--language_in=ECMASCRIPT5_STRICT",
     "--summary_detail_level=3",
     "--compilation_level=SIMPLE_OPTIMIZATIONS",
     "--source_map_format=V3",
+  ] + ["--jscomp_error=%s" % err for err in _COMMON_JSCOMP_ERROR]
+
+  # Extra flags used when compiling polymer code.

[Dan Beam, 2015/05/12 04:22:37]

Extra @jsDocAnnotations used when compiling Polymer code.

[Jeremy Klein, 2015/05/12 04:47:49]

Done.

+  _POLYMER_EXTRA_ANNOTATIONS = [
+    "attribute",
+    "status",
+    "element",
+    "homepage",
+    "submodule",
+    "group",
+  ]
+
+  _POLYMER_ARGS = [
+    "--polymer_pass",
+  ] + [
+    "--extra_annotation_name=%s" % annotation for annotation in
+        _POLYMER_EXTRA_ANNOTATIONS

[Dan Beam, 2015/05/12 04:22:37]

2 "annotations" in the same line (e.g.

  "--extra_annotation_name=%s" % a for a in _POLYMER_EXTRA_ANNOTATIONS

is probably enough)

[Jeremy Klein, 2015/05/12 04:47:49]

Done.

   ]
 
   # 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"
 
-  def __init__(self, verbose=False, strict=False):
+  def __init__(self, verbose=False, strict=False, polymer=False):
     """
     Args:
       verbose: Whether this class should output diagnostic messages.
       strict: Whether the Closure Compiler should be invoked more strictly.
+      polymer: Whether the Polymer pass is being run.

[Dan Beam, 2015/05/12 04:22:37]

  polymer: Whether the code requires Polymer support.

[Jeremy Klein, 2015/05/12 04:47:49]

Removed.

     """
-    current_dir = os.path.join(os.path.dirname(__file__))
-    self._runner_jar = os.path.join(current_dir, "runner", "runner.jar")
+    self._runner_jar = os.path.join(CURRENT_DIR, "runner", "runner.jar")
     self._temp_files = []
     self._verbose = verbose
     self._strict = strict
+    self._polymer = polymer
     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))
     for f in self._temp_files:
       os.remove(f)
@@ skipping 153 matching lines @@
     if out_file:
       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 self._polymer:
+      args += self._POLYMER_ARGS
+
     args_file_content = " %s" % " ".join(self._common_args() + 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")
@@ skipping 103 matching lines @@
   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("-w", "--output_wrapper",
                       help="Wraps output into this string at the place"
                          + " denoted by the marker token %output%")
   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("-p", "--polymer", type=int,
+                      help="'1' to run polymer-specific checks.")
   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 = opts.externs or set()
+  externs = set(opts.externs) or set()
+
+  if opts.polymer:
+    polymer_externs = os.path.join(CURRENT_DIR, os.pardir, 'polymer',
+                                   'v0_8', 'components-chromium',
+                                   'polymer-externs', 'polymer.externs.js')
+    externs.add(os.path.abspath(polymer_externs))
 
   if opts.out_file:
     out_dir = os.path.dirname(opts.out_file)
     if not os.path.exists(out_dir):
       os.makedirs(out_dir)
 
-  checker = Checker(verbose=opts.verbose, strict=opts.strict)
+  checker = Checker(verbose=opts.verbose, strict=opts.strict,
+                    polymer=opts.polymer)
   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)
       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)
     if found_errors:
       print stderr
       sys.exit(1)
 
   if opts.success_stamp:
     with open(opts.success_stamp, "w"):
       os.utime(opts.success_stamp, None)