closure_linter: 2.3.4 => 2.3.14

third_party/closure_linter/closure_linter/checker.py

Index: third_party/closure_linter/closure_linter/checker.py
diff --git a/third_party/closure_linter/closure_linter/checker.py b/third_party/closure_linter/closure_linter/checker.py
index 5c0fa81825887151868f4554a987fcc092f61037..41e52c3db56c744c619f5b3d436bf6647b483dbe 100755
--- a/third_party/closure_linter/closure_linter/checker.py
+++ b/third_party/closure_linter/closure_linter/checker.py
@@ -21,18 +21,12 @@ __author__ = ('robbyw@google.com (Robert Walker)',
 
 import gflags as flags
 
+from closure_linter import aliaspass
 from closure_linter import checkerbase
 from closure_linter import closurizednamespacesinfo
-from closure_linter import ecmametadatapass
 from closure_linter import javascriptlintrules
-from closure_linter import javascriptstatetracker
-from closure_linter.common import lintrunner
-
-flags.DEFINE_list('limited_doc_files', ['dummy.js', 'externs.js'],
-                  'List of files with relaxed documentation checks. Will not '
-                  'report errors for missing documentation, some missing '
-                  'descriptions, or methods whose @return tags don\'t have a '
-                  'matching return statement.')
+
+
 flags.DEFINE_list('closurized_namespaces', '',
                   'Namespace prefixes, used for testing of'
                   'goog.provide/require')
@@ -44,65 +38,64 @@ flags.DEFINE_list('ignored_extra_namespaces', '',
 class JavaScriptStyleChecker(checkerbase.CheckerBase):
   """Checker that applies JavaScriptLintRules."""
 
-  def __init__(self, error_handler):
+  def __init__(self, state_tracker, error_handler):
     """Initialize an JavaScriptStyleChecker object.
 
     Args:
+      state_tracker: State tracker.
       error_handler: Error handler to pass all errors to.
     """
     self._namespaces_info = None
+    self._alias_pass = None
     if flags.FLAGS.closurized_namespaces:
       self._namespaces_info = (
           closurizednamespacesinfo.ClosurizedNamespacesInfo(
               flags.FLAGS.closurized_namespaces,
               flags.FLAGS.ignored_extra_namespaces))
 
+      self._alias_pass = aliaspass.AliasPass(
+          flags.FLAGS.closurized_namespaces, error_handler)
+
     checkerbase.CheckerBase.__init__(
         self,
         error_handler=error_handler,
         lint_rules=javascriptlintrules.JavaScriptLintRules(
             self._namespaces_info),
-        state_tracker=javascriptstatetracker.JavaScriptStateTracker(),
-        metadata_pass=ecmametadatapass.EcmaMetaDataPass(),
-        limited_doc_files=flags.FLAGS.limited_doc_files)
+        state_tracker=state_tracker)
 
-  def _CheckTokens(self, token, parse_error, debug_tokens):
+  def Check(self, start_token, limited_doc_checks=False, is_html=False,
+            stop_token=None):
     """Checks a token stream for lint warnings/errors.
 
     Adds a separate pass for computing dependency information based on
     goog.require and goog.provide statements prior to the main linting pass.
 
     Args:
-      token: The first token in the token stream.
-      parse_error: A ParseError if any errors occurred.
-      debug_tokens: Whether every token should be printed as it is encountered
-          during the pass.
-
-    Returns:
-      A boolean indicating whether the full token stream could be checked or if
-      checking failed prematurely.
+      start_token: The first token in the token stream.
+      limited_doc_checks: Whether to perform limited checks.
+      is_html: Whether this token stream is HTML.
+      stop_token: If given, checks should stop at this token.
     """
+    self._lint_rules.Initialize(self, limited_doc_checks, is_html)
+
+    if self._alias_pass:
+      self._alias_pass.Process(start_token)
+
     # To maximize the amount of errors that get reported before a parse error
     # is displayed, don't run the dependency pass if a parse error exists.
-    if self._namespaces_info and not parse_error:
+    if self._namespaces_info:
       self._namespaces_info.Reset()
-      result = (self._ExecutePass(token, self._DependencyPass) and
-                self._ExecutePass(token, self._LintPass,
-                                  debug_tokens=debug_tokens))
-    else:
-      result = self._ExecutePass(token, self._LintPass, parse_error,
-                                 debug_tokens)
-
-    if not result:
-      return False
+      self._ExecutePass(start_token, self._DependencyPass, stop_token)
 
-    self._lint_rules.Finalize(self._state_tracker, self._tokenizer.mode)
+    self._ExecutePass(start_token, self._LintPass, stop_token)
 
-    self._error_handler.FinishFile()
-    return True
+    # If we have a stop_token, we didn't end up reading the whole file and,
+    # thus, don't call Finalize to do end-of-file checks.
+    if not stop_token:
+      self._lint_rules.Finalize(self._state_tracker)
 
   def _DependencyPass(self, token):
-    """Processes an invidual token for dependency information.
+    """Processes an individual token for dependency information.
 
     Used to encapsulate the logic needed to process an individual token so that
     it can be passed to _ExecutePass.
@@ -111,20 +104,3 @@ class JavaScriptStyleChecker(checkerbase.CheckerBase):
       token: The token to process.
     """
     self._namespaces_info.ProcessToken(token, self._state_tracker)
-
-
-class GJsLintRunner(lintrunner.LintRunner):
-  """Wrapper class to run GJsLint."""
-
-  def Run(self, filenames, error_handler):
-    """Run GJsLint on the given filenames.
-
-    Args:
-      filenames: The filenames to check
-      error_handler: An ErrorHandler object.
-    """
-    checker = JavaScriptStyleChecker(error_handler)
-
-    # Check the list of files.
-    for filename in filenames:
-      checker.Check(filename)