Closure compiler: fix incremental builds

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 165 matching lines @@
       content: A string of the file contens to write to a temporary file.
 
     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,
+  def _run_js_check(self, sources, out_file, externs=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.
       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)
+    assert out_file
+
+    out_dir = os.path.dirname(out_file)
+    if not os.path.exists(out_dir):
+      os.makedirs(out_dir)
+
+    checks_only = 'checks_only' in closure_args
+
+    if not checks_only:
       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", "continue_after_errors"]
     args += ["--%s" % arg for arg in closure_args]
 
     self._log_debug("Args: %s" % " ".join(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 errors:
       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)
+    elif checks_only:
+      # Compile succeeded but --checks_only disables --js_output_file from
+      # actually writing a file. Write a file ourselves so incremental builds
+      # still work.
+      with open(out_file, 'w') as f:
+        f.write('')
 
     return errors, stderr
 
   def check(self, source_file, out_file=None, depends=None, externs=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.
@@ skipping 71 matching lines @@
   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", required=True,
                       help="A file where the compiled output is written to")
   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 []
@@ skipping 19 matching lines @@
         sys.exit(1)
   else:
     found_errors, stderr = checker.check_multiple(
         sources,
         out_file=opts.out_file,
         externs=externs,
         closure_args=opts.closure_args)
     if found_errors:
       print stderr
       sys.exit(1)