Closure compilation: Remove compile_js2.py error filtering.

third_party/closure_compiler/compile2.py

 #!/usr/bin/python
 # Copyright 2015 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 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."""
 
   _JAR_COMMAND = [
@@ skipping 10 matching lines @@
 
   def __init__(self, verbose=False):
     """
     Args:
       verbose: Whether this class should output diagnostic messages.
     """
     self._compiler_jar = os.path.join(_CURRENT_DIR, "compiler", "compiler.jar")
     self._target = None
     self._temp_files = []
     self._verbose = verbose
-    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)
     self._temp_files = []
@@ skipping 56 matching lines @@
 
     Args:
       match: A re.MatchObject from matching against a line number regex.
 
     Returns:
       The fixed up /file and :line number.
     """
     real_file = self._processor.get_file_from_line(match.group(1))
     return "%s:%d" % (os.path.abspath(real_file.file), real_file.line_number)
 
-  def _filter_errors(self, errors):
-    """Removes some extraneous errors. For example, we ignore:
-
-      Variable x first declared in /tmp/expanded/file
-
-    Because it's just a duplicated error (it'll only ever show up 2+ times).
-    We also ignore Promise-based errors:
-
-      found   : function (VolumeInfo): (Promise<(DirectoryEntry|null)>|null)
-      required: (function (Promise<VolumeInfo>): ?|null|undefined)
-
-    as templates don't work with Promises in all cases yet. See
-    https://github.com/google/closure-compiler/issues/715 for details.
-
-    Args:
-      errors: A list of string errors extracted from Closure Compiler output.
-
-    Return:
-      A slimmer, sleeker list of relevant errors (strings).
-    """
-    first_declared_in = lambda e: " first declared in " not in e
-    return self._error_filter.filter(filter(first_declared_in, errors))
-
   def _clean_up_error(self, error):
     """Reverse the effects that funky <include> preprocessing steps have on
     errors messages.
 
     Args:
       error: A Closure compiler error (2 line string with error and source).
 
     Return:
       The fixed up error string.
     """
@@ skipping 130 matching lines @@
       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('')
 
     if process_includes:
-      filtered_errors = self._filter_errors(errors)
-      errors = map(self._clean_up_error, filtered_errors)
+      errors = map(self._clean_up_error, errors)
       output = self._format_errors(errors)
 
       if errors:
         prefix = "\n" if output else ""
         self._log_error("Error in: %s%s%s" % (self._target, prefix, output))
       elif output:
         self._log_debug("Output: %s" % output)
 
     self._nuke_temp_files()
     return bool(errors), stderr
@@ skipping 21 matching lines @@
 
   found_errors, stderr = checker.check(opts.sources, out_file=opts.out_file,
                                        closure_args=opts.closure_args,
                                        custom_sources=opts.custom_sources,
                                        custom_includes=opts.custom_includes)
 
   if found_errors:
     if opts.custom_sources:
       print stderr
     sys.exit(1)