Handle ES6 export/import name as alias syntax in VarCheck correctly for nonlocal names.

Examples:
let a; export {a as b}; // b isn't and shouldn't be defined in the module or global scope
import {b as a} from './foo.js'; // same

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=172157001

Author: lauraharker

src/com/google/javascript/jscomp/MakeDeclaredNamesUnique.java

@@ -130,8 +130,7 @@ public void visit(NodeTraversal t, Node n, Node parent) {
 
   private void visitName(NodeTraversal t, Node n, Node parent) {
     // Don't rename the exported name foo in export {a as foo}; or import {foo as b};
-    if (parent != null && ((parent.isImportSpec() && parent.getFirstChild() == n)
-        || (parent.isExportSpec() && parent.getLastChild() == n))) {
+    if (NodeUtil.isNonlocalModuleExportName(n)) {
       return;
     }
     String newName = getReplacementName(n.getString());

src/com/google/javascript/jscomp/NodeUtil.java

@@ -2684,6 +2684,19 @@ static boolean isReferenceName(Node n) {
     return n.isName() && !n.getString().isEmpty();
   }
 
+  /**
+   * @return Whether the name in an import or export spec is not defined within the module, but is
+   *     an exported name from this or another module. e.g. nonlocal in "export {a as nonlocal}" or
+   *     "import {nonlocal as a} from './foo.js'"
+   */
+  static boolean isNonlocalModuleExportName(Node n) {
+    Node parent = n.getParent();
+    return (parent != null
+            && n.isName()
+            && ((parent.isExportSpec() && n != parent.getFirstChild())
+                || (parent.isImportSpec() && n != parent.getLastChild())));
+  }
+
   /** Whether the child node is the FINALLY block of a try. */
   static boolean isTryFinallyNode(Node parent, Node child) {
     return parent.isTry() && parent.hasXChildren(3)

src/com/google/javascript/jscomp/VarCheck.java

@@ -196,6 +196,9 @@ public void visit(NodeTraversal t, Node n, Node parent) {
             || (NodeUtil.isClassExpression(parent) && n == parent.getFirstChild())) {
           // e.g. [ function foo() {} ], it's okay if "foo" isn't defined in the
           // current scope.
+        } else if (NodeUtil.isNonlocalModuleExportName(n)) {
+          // e.g. "export {a as b}" or "import {b as a} from './foo.js'
+          // where b is defined in a module's export entries but not in any module scope.
         } else {
           boolean isArguments = scope.isFunctionScope() && ARGUMENTS.equals(varName);
           // The extern checks are stricter, don't report a second error.

test/com/google/javascript/jscomp/NodeUtilTest.java

@@ -866,6 +866,61 @@ private void assertNodeNames(Set<String> nodeNames, Collection<Node> nodes) {
     assertEquals(nodeNames, actualNames);
   }
 
+  public void testIsNonlocalModuleExportNameOnExports1() {
+    Node root = parse("export {localName as exportName};");
+    Node moduleBody = root.getFirstChild();
+    Node exportNode = moduleBody.getFirstChild();
+    Node exportSpecs = exportNode.getFirstChild();
+    Node exportSpec = exportSpecs.getFirstChild();
+
+    Node localName = exportSpec.getFirstChild();
+    Node exportName = exportSpec.getSecondChild();
+
+    assertFalse(NodeUtil.isNonlocalModuleExportName(localName));
+    assertTrue(NodeUtil.isNonlocalModuleExportName(exportName));
+
+  }
+
+  public void testIsNonlocalModuleExportNameOnExports2() {
+    Node root = parse("let bar; export {bar};");
+    Node moduleBody = root.getFirstChild();
+    Node exportNode = moduleBody.getSecondChild();
+    Node exportSpecs = exportNode.getFirstChild();
+    Node exportSpec = exportSpecs.getFirstChild();
+
+    Node name = exportSpec.getFirstChild();
+
+    // bar is defined locally, so isNonlocalModuleExportName is false.
+    assertFalse(NodeUtil.isNonlocalModuleExportName(name));
+  }
+
+  public void testIsNonlocalModuleExportNameOnImports1() {
+    Node root = parse("import {exportName as localName} from './foo.js';");
+    Node moduleBody = root.getFirstChild();
+    Node importNode = moduleBody.getFirstChild();
+    Node importSpecs = importNode.getSecondChild();
+    Node importSpec = importSpecs.getFirstChild();
+
+    Node exportName = importSpec.getFirstChild();
+    Node localName = importSpec.getSecondChild();
+
+    assertTrue(NodeUtil.isNonlocalModuleExportName(exportName));
+    assertFalse(NodeUtil.isNonlocalModuleExportName(localName));
+  }
+
+  public void testIsNonlocalModuleExportNameOnImports2() {
+    Node root = parse("import {bar} from './foo.js';");
+    Node moduleBody = root.getFirstChild();
+    Node importNode = moduleBody.getFirstChild();
+    Node importSpecs = importNode.getSecondChild();
+    Node importSpec = importSpecs.getFirstChild();
+
+    Node name = importSpec.getFirstChild();
+
+    // bar is defined locally so isNonlocalModuleExportName is false
+    assertFalse(NodeUtil.isNonlocalModuleExportName(name));
+  }
+
   public void testIsControlStructureCodeBlock() {
     Node root = parse("if (x) foo(); else boo();");
     Node ifNode = root.getFirstChild();

test/com/google/javascript/jscomp/VarCheckTest.java

@@ -680,6 +680,22 @@ public void testImportStar() {
     testSame("import * as foo from './foo.js';");
   }
 
+  public void testExportAsAlias() {
+    testSame("let a = 1; export {a as b};");
+    testError("let a = 1; export {b as a};", VarCheck.UNDEFINED_VAR_ERROR);
+    testError("export {a as a};", VarCheck.UNDEFINED_VAR_ERROR);
+
+    // Make sure non-aliased exports still work correctly.
+    testSame("let a = 1; export {a}");
+    testError("let a = 1; export {b};", VarCheck.UNDEFINED_VAR_ERROR);
+  }
+
+  public void testImportAsAlias() {
+    testSame("import {b as a} from './foo.js'; let c = a;");
+    testError("import {b as a} from './foo.js'; let c = b;", VarCheck.UNDEFINED_VAR_ERROR);
+    testSame("import {a} from './foo.js'; let c = a;");
+  }
+
   private static final class VariableTestCheck implements CompilerPass {
 
     final AbstractCompiler compiler;