Update Chromoting to use /third_party/closure_compiler.

third_party/closure_compiler/checker.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 a JavaScript file to check for errors."""
 
 import argparse
 import os
 import re
@@ skipping 24 matching lines @@
     "--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",
+  ]
+
+  # 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",

[Tyler Breisacher (Chromium), 2015/01/12 20:35:15]

We generally don't recommend people use this flag. It's rare that you'll have
type information for every single node in your entire program.

[Jamie, 2015/01/12 20:45:09]

We took a decision back at the start of the project that we would do this. It's
sometimes painful to annotate everything, but it's caught some bugs that would
otherwise have gone undetected. Perhaps the compiler has improved to the point
that it's no longer necessary, but the incremental cost of continuing to
annotate everything is relatively low at this point, so we'd like to keep it.

+    "--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",
-    "--language_in=ECMASCRIPT5_STRICT",
-    "--summary_detail_level=3",
   ]
 
   _JAR_COMMAND = [
     "java",
     "-jar",
     "-Xms1024m",
     "-client",
     "-XX:+TieredCompilation"
   ]
 
   _found_java = False
 
-  def __init__(self, verbose=False):
+  def __init__(self, verbose=False, strict=False):
     current_dir = os.path.join(os.path.dirname(__file__))
-    self._compiler_jar = os.path.join(current_dir, "lib", "compiler.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 _clean_up(self):
     if not self._temp_files:
       return
 
     self._debug("Deleting temporary files: %s" % ", ".join(self._temp_files))
     for f in self._temp_files:
       os.remove(f)
     self._temp_files = []
 
   def _debug(self, msg, error=False):
     if self._verbose:
       print "(INFO) %s" % msg
 
   def _error(self, msg):
     print >> sys.stderr, "(ERROR) %s" % msg
     self._clean_up()
 
+  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_command(self, cmd):
     """Runs a shell command.
 
     Args:
         cmd: A list of tokens to be joined into a shell command.
 
     Return:
         True if the exit code was 0, else False.
     """
     cmd_str = " ".join(cmd)
@@ skipping 54 matching lines @@
     errors = filter(None, errors)
     contents = "\n## ".join("\n\n".join(errors).splitlines())
     return "## %s" % contents if contents else ""
 
   def _create_temp_file(self, contents):
     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 check(self, source_file, depends=None, externs=None):

[Tyler Breisacher (Chromium), 2015/01/12 20:35:15]

Would it make sense for check() to just call check_multiple passing a
one-element list, so that you don't have to duplicate a lot of logic between the
two?

[garykac, 2015/01/13 00:28:39]

The single-file code path does a bunch of stuff:
* combine source + includes into a temp file
* fixup the error messages because they no longer match the source
* filter out some error messages
That we would rather not do - for our use it seems unnecessary and more complex
that just using the source files directly.

But it's easy enough to extract the common code into a helper function. PTAL

     """Closure compile a file and check for errors.
 
     Args:
         source_file: A file to check.
         depends: Other files that would be included with a <script> earlier in
             the page.
         externs: @extern files that inform the compiler about custom globals.
 
     Returns:
-        (exitcode, output) The exit code of the Closure compiler (as a number)
-            and its output (as a string).
+        (has_errors, output) A boolean indicating if there were errors and the
+            Closure compiler output (as a string).
     """
     depends = depends or []
     externs = externs or set()
 
     if not self._check_java_path():
       return 1, ""
 
     self._debug("FILE: %s" % source_file)
 
     if source_file.endswith("_externs.js"):
       self._debug("Skipping externs: %s" % source_file)
       return
 
     self._file_arg = source_file
 
     tmp_dir = tempfile.gettempdir()
     rel_path = lambda f: os.path.join(os.path.relpath(os.getcwd(), tmp_dir), f)
 
     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._debug("Meta file: %s" % meta_file)
 
     self._processor = processor.Processor(meta_file)
     self._expanded_file = self._create_temp_file(self._processor.contents)
     self._debug("Expanded file: %s" % self._expanded_file)
 
     args = ["--js=%s" % self._expanded_file]
     args += ["--externs=%s" % e for e in externs]
-    args_file_content = " %s" % " ".join(self._COMMON_CLOSURE_ARGS + args)
+    args_file_content = " %s" % " ".join(self._common_args() + args)
     self._debug("Args: %s" % args_file_content.strip())
 
     args_file = self._create_temp_file(args_file_content)
     self._debug("Args file: %s" % args_file)
 
     runner_args = ["--compiler-args-file=%s" % args_file]
     runner_cmd = self._run_jar(self._runner_jar, args=runner_args)
     (_, stderr) = runner_cmd.communicate()
 
     errors = stderr.strip().split("\n\n")
 
     # Filter out false-positive promise chain errors.
     # See https://github.com/google/closure-compiler/issues/715 for details.
     errors = self._error_filter.filter(errors);
 
     self._debug("Summary: %s" % errors.pop())
 
     output = self._format_errors(map(self._fix_up_error, errors))
     if errors:
       prefix = "\n" if output else ""
       self._error("Error in: %s%s%s" % (source_file, prefix, output))
     elif output:
       self._debug("Output: %s" % output)
 
     self._clean_up()
 
     return bool(errors), output
 
+  def check_multiple(self, sources):
+    """Closure compile a set of files and check for errors.
+
+    Args:
+        sources: An array of files to check.
+
+    Returns:
+        (has_errors, output) A boolean indicating if there were errors and the
+            Closure compiler output (as a string).
+    """
+
+    if not self._check_java_path():
+      return 1, ""
+
+    args = ["--js=%s" % s for s in sources]
+    args_file_content = " %s" % " ".join(self._common_args() + args)
+    self._debug("Args: %s" % args_file_content.strip())
+
+    args_file = self._create_temp_file(args_file_content)
+    self._debug("Args file: %s" % args_file)
+
+    runner_args = ["--compiler-args-file=%s" % args_file]
+    runner_cmd = self._run_jar(self._runner_jar, args=runner_args)
+    (_, stderr) = runner_cmd.communicate()
+
+    errors = stderr.strip().split("\n\n")
+    self._debug("Summary: %s" % errors.pop())
+
+    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")
+  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 place to output results")
   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()
 
-  checker = Checker(verbose=opts.verbose)
-  for source in opts.sources:
-    depends, externs = build.inputs.resolve_recursive_dependencies(
-        source,
-        opts.depends,
-        opts.externs)
-    exit, _ = checker.check(source, depends=depends, externs=externs)
-    if exit != 0:
+  depends = opts.depends or []
+  externs = opts.externs or set()
+
+  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)
+      has_errors, _ = checker.check(source, depends=depends, externs=externs)
+      if has_errors:
+        sys.exit(exit)

[Tyler Breisacher (Chromium), 2015/01/12 20:35:15]

It looks like 'exit' is no longer defined. Maybe just sys.exit(1) or something.

[garykac, 2015/01/13 00:28:39]

Done.

+
+      if opts.out_file:
+        out_dir = os.path.dirname(opts.out_file)
+        if not os.path.exists(out_dir):
+          os.makedirs(out_dir)
+        # TODO(dbeam): write compiled file to |opts.out_file|.
+        open(opts.out_file, "w").write("")
+  else:
+    has_errors, _ = checker.check_multiple(opts.sources)
+    if has_errors:
+      print _
       sys.exit(exit)
 
-    if opts.out_file:
-      out_dir = os.path.dirname(opts.out_file)
-      if not os.path.exists(out_dir):
-        os.makedirs(out_dir)
-      # TODO(dbeam): write compiled file to |opts.out_file|.
-      open(opts.out_file, "w").write("")
+  if opts.success_stamp:
+    with open(opts.success_stamp, 'w'):
+      os.utime(opts.success_stamp, None)