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__))
+
+
 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",
-    "--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",
+    "--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",
   ]
 
@@ skipping 14 matching lines @@
   ]
 
   _MAP_FILE_FORMAT = "%s.map"
 
   def __init__(self, verbose=False, strict=False):
     """
     Args:
       verbose: Whether this class should output diagnostic messages.
       strict: Whether the Closure Compiler should be invoked more strictly.
     """
-    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._error_filter = error_filter.PromiseErrorFilter()
 
   def _nuke_temp_files(self):
     """Deletes any temp files this class knows about."""
     if not self._temp_files:
       return
 
@@ skipping 237 matching lines @@
 
     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):
+  def check_multiple(self, sources, out_file=None, output_wrapper=None,
+                     externs=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.
 
     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)
+                                        output_wrapper=output_wrapper,
+                                        externs=externs)
     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()
@@ skipping 14 matching lines @@
                       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 = opts.externs or set()
+  externs = set(opts.externs or [])
+
+  polymer_externs = os.path.join(os.path.dirname(_CURRENT_DIR), 'polymer',
+                                 'v0_8', 'components-chromium',
+                                 'polymer-externs', 'polymer.externs.js')
+  externs.add(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)
   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)
+        output_wrapper=opts.output_wrapper,
+        externs=externs)
     if found_errors:
       print stderr
       sys.exit(1)
 
   if opts.success_stamp:
     with open(opts.success_stamp, "w"):
       os.utime(opts.success_stamp, None)