Updated linter with upstream release (2.3.19)

third_party/closure_linter/closure_linter/scopeutil.py

 #!/usr/bin/env python
 #
 # Copyright 2012 The Closure Linter Authors. All Rights Reserved.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
@@ skipping 102 matching lines @@
   Returns:
     True if symbol is an identifier in a Closurized namespace, otherwise False.
   """
   for ns in closurized_namespaces:
     if symbol.startswith(ns + '.'):
       return True
 
   return False
 
 
-def MatchAlias(context):
-  """Match an alias statement (some identifier assigned to a variable).
-
-  Example alias: var MyClass = proj.longNamespace.MyClass.
+def _GetVarAssignmentTokens(context):
+  """Returns the tokens from context if it is a var assignment.
 
   Args:
-    context: An EcmaContext of type EcmaContext.VAR.
+    context: An EcmaContext.
 
   Returns:
-    If a valid alias, returns a tuple of alias and symbol, otherwise None.
+    If a var assignment, the tokens contained within it w/o the trailing
+    semicolon.
   """
   if context.type != ecmametadatapass.EcmaContext.VAR:
     return
 
-  # The var's parent is a STATEMENT, which should be directly below goog.scope.
-  if not IsGoogScopeBlock(context.parent.parent):
-    return
-
   # Get the tokens in this statement.
   if context.start_token and context.end_token:
     statement_tokens = tokenutil.GetTokenRange(context.start_token,
                                                context.end_token)
   else:
     return
 
   # And now just those tokens that are actually code.
   is_non_code_type = lambda t: t.type not in JavaScriptTokenType.NON_CODE_TYPES
   code_tokens = filter(is_non_code_type, statement_tokens)
 
-  # This section identifies statements of the alias form "var alias = symbol".
-
   # Pop off the semicolon if present.
   if code_tokens and code_tokens[-1].IsType(JavaScriptTokenType.SEMICOLON):
     code_tokens.pop()
 
   if len(code_tokens) < 4:
     return
 
-  # Verify that this is of the form "var lvalue = identifier;".
-  # The identifier may span multiple lines and could be multiple tokens.
   if (code_tokens[0].IsKeyword('var') and
       code_tokens[1].IsType(JavaScriptTokenType.SIMPLE_LVALUE) and
-      code_tokens[2].IsOperator('=') and
-      all(t.IsType(JavaScriptTokenType.IDENTIFIER) for t in code_tokens[3:])):
+      code_tokens[2].IsOperator('=')):
+    return code_tokens
+
+
+def MatchAlias(context):
+  """Match an alias statement (some identifier assigned to a variable).
+
+  Example alias: var MyClass = proj.longNamespace.MyClass.
+
+  Args:
+    context: An EcmaContext of type EcmaContext.VAR.
+
+  Returns:
+    If a valid alias, returns a tuple of alias and symbol, otherwise None.
+  """
+  code_tokens = _GetVarAssignmentTokens(context)
+  if code_tokens is None:
+    return
+
+  if all(tokenutil.IsIdentifierOrDot(t) for t in code_tokens[3:]):
+    # var Foo = bar.Foo;
     alias, symbol = code_tokens[1], code_tokens[3]
-    # Mark both tokens as an alias definition to avoid counting them as usages.
+    # Mark both tokens as an alias definition to not count them as usages.
     alias.metadata.is_alias_definition = True
     symbol.metadata.is_alias_definition = True
+    return alias.string, tokenutil.GetIdentifierForToken(symbol)
 
-    return alias.string, tokenutil.GetIdentifierForToken(symbol)
+
+def MatchModuleAlias(context):
+  """Match an alias statement in a goog.module style import.
+
+  Example alias: var MyClass = goog.require('proj.longNamespace.MyClass').
+
+  Args:
+    context: An EcmaContext.
+
+  Returns:
+    If a valid alias, returns a tuple of alias and symbol, otherwise None.
+  """
+  code_tokens = _GetVarAssignmentTokens(context)
+  if code_tokens is None:
+    return
+
+  if(code_tokens[3].IsType(JavaScriptTokenType.IDENTIFIER) and
+     code_tokens[3].string == 'goog.require'):
+    # var Foo = goog.require('bar.Foo');
+    alias = code_tokens[1]
+    symbol = tokenutil.GetStringAfterToken(code_tokens[3])
+    if symbol:
+      alias.metadata.is_alias_definition = True
+      return alias.string, symbol