Change string concatentation from + to % in part of 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 50 matching lines @@
     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
 
   def _clean_up(self):
     if not self._temp_files:
       return
 
-    self._debug("Deleting temporary files: " + ", ".join(self._temp_files))
+    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) " + msg
+      print "(INFO) %s" % msg
 
   def _error(self, msg):
-    print >> sys.stderr, "(ERROR) " + msg
+    print >> sys.stderr, "(ERROR) %s" % msg
     self._clean_up()
 
   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)
-    self._debug("Running command: " + cmd_str)
+    self._debug("Running command: %s" % cmd_str)
 
     devnull = open(os.devnull, "w")
     return subprocess.Popen(
         cmd_str, stdout=devnull, stderr=subprocess.PIPE, shell=True)
 
   def _check_java_path(self):
     """Checks that `java` is on the system path."""
     if not self._found_java:
       proc = self._run_command(["which", "java"])
       proc.communicate()
@@ skipping 34 matching lines @@
       # Ignore "Variable x first declared in /same/file".
       return ""
 
     expanded_file = self._expanded_file
     fixed = re.sub("%s:(\d+)" % expanded_file, self._fix_line_number, error)
     return fixed.replace(expanded_file, os.path.abspath(self._file_arg))
 
   def _format_errors(self, errors):
     """Formats Closure compiler errors to easily spot compiler output."""
     errors = filter(None, errors)
-    contents = ("\n" + "## ").join("\n\n".join(errors).splitlines())
-    return "## " + contents if contents else ""
+    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):
     """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).
     """
     depends = depends or []
     externs = externs or []
 
     if not self._check_java_path():
       return 1, ""
 
-    self._debug("FILE: " + source_file)
+    self._debug("FILE: %s" % source_file)
 
     if source_file.endswith("_externs.js"):
-      self._debug("Skipping externs: " + source_file)
+      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: " + meta_file)
+    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: " + self._expanded_file)
+    self._debug("Expanded file: %s" % self._expanded_file)
 
-    args = ["--js=" + self._expanded_file] + ["--externs=" + e for e in externs]
-    args_file_content = " " + " ".join(self._COMMON_CLOSURE_ARGS + args)
-    self._debug("Args: " + args_file_content.strip())
+    args = ["--js=%s" % self._expanded_file]
+    args += ["--externs=%s" % e for e in externs]
+    args_file_content = " %s" % " ".join(self._COMMON_CLOSURE_ARGS + args)
+    self._debug("Args: %s" % args_file_content.strip())
 
     args_file = self._create_temp_file(args_file_content)
-    self._debug("Args file: " + args_file)
+    self._debug("Args file: %s" % args_file)
 
-    runner_args = ["--compiler-args-file=" + 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: " + errors.pop())
+    self._debug("Summary: %s" % errors.pop())
 
     output = self._format_errors(map(self._fix_up_error, errors))
     if runner_cmd.returncode:
-      self._error("Error in: " + source_file + ("\n" + output if output else ""))
+      self._error("Error in: %s%s" % (source_file, "\n" + output if output else ""))
     elif output:
-      self._debug("Output: " + output)
+      self._debug("Output: %s" % output)
 
     self._clean_up()
 
     return runner_cmd.returncode, output
 
 
 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")
   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")
   opts = parser.parse_args()
 
   checker = Checker(verbose=opts.verbose)
   for source in opts.sources:
     if not checker.check(source, depends=opts.depends, externs=opts.externs):
       sys.exit(1)
 
     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("")