Make SymbolTable's property scope building support class-side inherit…

…ance

The only real change is that SymbolTable#createPropertyScopeFor now supports cases where an object's implicit prototype is a class, and can resolve references to statically inherited properties.

Also adds a package-private option to run passes in PhaseOptimizer even if they don't support all features in the current AST.

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

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

@@ -119,6 +119,14 @@ public enum PropertyCollapseLevel {
 
   private Optional<Boolean> languageOutIsDefaultStrict = Optional.absent();
 
+  /**
+   * Skips passes (logging a warning) whose PassFactory feature set doesn't include some features
+   * currently in the AST.
+   *
+   * <p>At the moment, this should only ever be set to false for testing.
+   */
+  private boolean skipUnsupportedPasses = true;
+
   /**
    * The builtin set of externs to be used
    */
@@ -1985,6 +1993,24 @@ public FeatureSet getOutputFeatureSet() {
     return languageIn.toFeatureSet();
   }
 
+  /**
+   * Sets the behavior of PhaseOptimizer when given a pass that can't handle features in the current
+   * AST.
+   *
+   * <p>Currently the only options are either to run the pass anyway, and see what happens, or to
+   * skip the pass and log a warning. Only test code should do the former.
+   *
+   * <p>In the future we may make this option public. We may also make it into an enum, and add an
+   * option to throw runtime errors upon seeing unsupported passses.
+   */
+  void setSkipUnsupportedPasses(boolean skipUnsupportedPasses) {
+    this.skipUnsupportedPasses = skipUnsupportedPasses;
+  }
+
+  boolean shouldSkipUnsupportedPasses() {
+    return skipUnsupportedPasses;
+  }
+
   public boolean needsTranspilationFrom(FeatureSet languageLevel) {
     // TODO(johnplaisted): This isn't really accurate. This should instead be the *parsed* language,
     // not the *input* language.

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

@@ -276,7 +276,8 @@ class NamedPass implements CompilerPass {
 
     @Override
     public void process(Node externs, Node root) {
-      if (!factory.featureSet().contains(compiler.getFeatureSet())) {
+      if (compiler.getOptions().shouldSkipUnsupportedPasses()
+          && !factory.featureSet().contains(compiler.getFeatureSet())) {
         // NOTE: this warning ONLY appears in code using the Google-internal runner.
         // Both CommandLineRunner.java and gwt/client/GwtRunner.java explicitly set the logging
         // level to Level.OFF to avoid seeing this warning.

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

@@ -974,22 +974,18 @@ private void createPropertyScopeFor(Symbol s) {
       return;
     }
 
-    SymbolScope parentPropertyScope = null;
-
     ObjectType type = getType(s) == null ? null : getType(s).toObjectType();
     if (type == null) {
       return;
     }
 
-    ObjectType proto = type.getImplicitPrototype();
-    if (proto != null && proto != type && proto.getConstructor() != null) {
-      Symbol parentSymbol = getSymbolForInstancesOf(proto.getConstructor());
-      if (parentSymbol != null) {
-        createPropertyScopeFor(parentSymbol);
-        parentPropertyScope = parentSymbol.getPropertyScope();
-      }
-    }
+    // Create an empty property scope for the given symbol, maybe with a parent scope if it has
+    // an implicit prototype.
+    SymbolScope parentPropertyScope = maybeGetParentPropertyScope(type);
+    s.setPropertyScope(new SymbolScope(null, parentPropertyScope, type, s));
 
+    // If this symbol represents some 'a.b.c.prototype', add any instance properties of a.b.c
+    // into the symbol scope.
     ObjectType instanceType = type;
     Iterable<String> propNames = type.getOwnPropertyNames();
     if (instanceType.isFunctionPrototypeType()) {
@@ -1001,7 +997,7 @@ private void createPropertyScopeFor(Symbol s) {
       }
     }
 
-    s.setPropertyScope(new SymbolScope(null, parentPropertyScope, type, s));
+    // Add all declared properties in propNames into the property scope
     for (String propName : propNames) {
       StaticSlot newProp = instanceType.getSlot(propName);
       if (newProp.getDeclaration() == null) {
@@ -1044,6 +1040,46 @@ private void createPropertyScopeFor(Symbol s) {
     }
   }
 
+  /**
+   * If this type has an implicit prototype set, returns the SymbolScope corresponding to the
+   * properties of the implicit prototype. Otherwise returns null.
+   *
+   * <p>Note that currently we only handle cases where the implicit prototype is a) a class or b) is
+   * an instance object.
+   */
+  @Nullable
+  private SymbolScope maybeGetParentPropertyScope(ObjectType symbolObjectType) {
+    ObjectType proto = symbolObjectType.getImplicitPrototype();
+    if (proto == null || proto == symbolObjectType) {
+      return null;
+    }
+    final Symbol parentSymbol;
+    if (isEs6ClassConstructor(proto)) {
+      // given `class Foo {} class Bar extends Foo {}`, `Foo` is the implicit prototype of `Bar`.
+      parentSymbol = getSymbolDeclaredBy(proto.toMaybeFunctionType());
+    } else if (proto.getConstructor() != null) {
+      // given
+      //   /** @constructor */ function Foo() {}
+      //   /** @constructor */ function Bar() {}
+      //   goog.inherits(Bar, Foo);
+      // the implicit prototype of Bar.prototype is the instance of Foo.
+      parentSymbol = getSymbolForInstancesOf(proto.getConstructor());
+    } else {
+      return null;
+    }
+    if (parentSymbol == null) {
+      return null;
+    }
+    createPropertyScopeFor(parentSymbol);
+    return parentSymbol.getPropertyScope();
+  }
+
+  private boolean isEs6ClassConstructor(JSType type) {
+    return type.isFunctionType()
+        && type.toMaybeFunctionType().getSource() != null
+        && type.toMaybeFunctionType().getSource().isClass();
+  }
+
   /** Fill in references to "this" variables. */
   void fillThisReferences(Node externs, Node root) {
     (new ThisRefCollector()).process(externs, root);

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

@@ -217,6 +217,20 @@ public void testProgress() {
     assertEquals(100, Math.round(progressList.get(3)));
   }
 
+  @Test
+  public void testSetSkipUnsupportedPasses() {
+    compiler.getOptions().setSkipUnsupportedPasses(true);
+    addUnsupportedPass("testPassFactory");
+    assertPasses();
+  }
+
+  @Test
+  public void testSetDontSkipUnsupportedPasses() {
+    compiler.getOptions().setSkipUnsupportedPasses(false);
+    addUnsupportedPass("testPassFactory");
+    assertPasses("testPassFactory");
+  }
+
   public void assertPasses(String ... names) {
     optimizer.process(null, dummyRoot);
     assertEquals(ImmutableList.copyOf(names), passesRun);
@@ -232,13 +246,25 @@ private void addLoopedPass(Loop loop, String name, int numChanges) {
         createPassFactory(name, numChanges, false));
   }
 
+  /** Adds a pass with the given name that does not support some of the features used in the AST. */
+  private void addUnsupportedPass(String name) {
+    compiler.setFeatureSet(FeatureSet.latest());
+    optimizer.addOneTimePass(
+        createPassFactory(name, createPass(name, 0), true, FeatureSet.BARE_MINIMUM));
+  }
+
   private PassFactory createPassFactory(
       String name, int numChanges, boolean isOneTime) {
     return createPassFactory(name, createPass(name, numChanges), isOneTime);
   }
 
   private PassFactory createPassFactory(
       String name, final CompilerPass pass, boolean isOneTime) {
+    return createPassFactory(name, pass, isOneTime, FeatureSet.latest());
+  }
+
+  private PassFactory createPassFactory(
+      String name, final CompilerPass pass, boolean isOneTime, FeatureSet featureSet) {
     return new PassFactory(name, isOneTime) {
       @Override
       protected CompilerPass create(AbstractCompiler compiler) {
@@ -247,7 +273,7 @@ protected CompilerPass create(AbstractCompiler compiler) {
 
       @Override
       public FeatureSet featureSet() {
-        return FeatureSet.latest();
+        return featureSet;
       }
     };
   }

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

@@ -15,9 +15,12 @@
  */
 package com.google.javascript.jscomp;
 
+import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.javascript.jscomp.CompilerTestCase.lines;
 import static com.google.javascript.jscomp.parsing.Config.JsDocParsing.INCLUDE_DESCRIPTIONS_NO_WHITESPACE;
+import static com.google.javascript.rhino.testing.NodeSubject.assertNode;
+import static com.google.javascript.rhino.testing.TypeSubject.assertType;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Ordering;
@@ -30,6 +33,7 @@
 import com.google.javascript.rhino.JSDocInfo.Visibility;
 import com.google.javascript.rhino.Node;
 import com.google.javascript.rhino.Token;
+import com.google.javascript.rhino.jstype.FunctionType;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -40,7 +44,11 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** @author nicksantos@google.com (Nick Santos) */
+/**
+ * An integration test for symbol table creation
+ *
+ * @author nicksantos@google.com (Nick Santos)
+ */
 
 @RunWith(JUnit4.class)
 public final class SymbolTableTest extends TestCase {
@@ -419,9 +427,11 @@ public void testSymbolsForType() {
     Symbol bar = getGlobalVar(table, "Bar");
     Symbol fooPrototype = getGlobalVar(table, "Foo.prototype");
     Symbol fn = getGlobalVar(table, "Function");
-    assertEquals(ImmutableList.of(foo, bar), table.getAllSymbolsForTypeOf(x));
-    assertEquals(ImmutableList.of(fn), table.getAllSymbolsForTypeOf(foo));
-    assertEquals(ImmutableList.of(foo), table.getAllSymbolsForTypeOf(fooPrototype));
+    assertThat(table.getAllSymbolsForTypeOf(x))
+        .containsExactlyElementsIn(ImmutableList.of(foo, bar));
+    assertThat(table.getAllSymbolsForTypeOf(foo)).containsExactlyElementsIn(ImmutableList.of(fn));
+    assertThat(table.getAllSymbolsForTypeOf(fooPrototype))
+        .containsExactlyElementsIn(ImmutableList.of(foo));
     assertEquals(foo, table.getSymbolDeclaredBy(foo.getType().toMaybeFunctionType()));
   }
 
@@ -1320,6 +1330,41 @@ public void testGetEnclosingFunctionScope_FunctionInsideFunction() {
     assertEquals(foo, bazFunctionScope.getRootNode());
   }
 
+  @Test
+  public void testSymbolSuperclassStaticInheritance() {
+    // set this option so that typechecking sees untranspiled classes.
+    // TODO(b/76025401): remove this option after class transpilation is always post-typechecking
+    options.setLanguageOut(LanguageMode.ECMASCRIPT_2015);
+    options.setSkipUnsupportedPasses(false);
+
+    SymbolTable table =
+        createSymbolTable(
+            lines(
+                "class Bar { static staticMethod() {} }",
+                "class Foo extends Bar {",
+                "  act() { Foo.staticMethod(); }",
+                "}"));
+
+    Symbol foo = getGlobalVar(table, "Foo");
+    Symbol bar = getGlobalVar(table, "Bar");
+
+    FunctionType barType = checkNotNull(bar.getType().toMaybeFunctionType());
+    FunctionType fooType = checkNotNull(foo.getType().toMaybeFunctionType());
+
+    FunctionType superclassCtorType = fooType.getSuperClassConstructor();
+
+    assertType(superclassCtorType).isEqualTo(barType);
+    Symbol superSymbol = table.getSymbolDeclaredBy(superclassCtorType);
+    assertThat(superSymbol).isEqualTo(bar);
+
+    Symbol barStaticMethod = getGlobalVar(table, "Bar.staticMethod");
+    ImmutableList<Reference> barStaticMethodRefs = table.getReferenceList(barStaticMethod);
+    assertThat(barStaticMethodRefs).hasSize(2);
+    assertThat(barStaticMethodRefs.get(0)).isEqualTo(barStaticMethod.getDeclaration());
+    // We recognize that the call to Foo.staticMethod() is actually a call to Bar.staticMethod().
+    assertNode(barStaticMethodRefs.get(1).getNode()).matchesQualifiedName("Foo.staticMethod");
+  }
+
   private void assertSymmetricOrdering(Ordering<Symbol> ordering, Symbol first, Symbol second) {
     assertEquals(0, ordering.compare(first, first));
     assertEquals(0, ordering.compare(second, second));
@@ -1363,12 +1408,7 @@ private List<Symbol> getVars(SymbolTable table) {
   }
 
   private SymbolTable createSymbolTable(String input) {
-    List<SourceFile> inputs = ImmutableList.of(SourceFile.fromCode("in1", input));
-    List<SourceFile> externs = ImmutableList.of(SourceFile.fromCode("externs1", EXTERNS));
-
-    Compiler compiler = new Compiler(new BlackHoleErrorManager());
-    compiler.compile(externs, inputs, options);
-    return assertSymbolTableValid(compiler.buildKnownSymbolTable());
+    return createSymbolTable(input, EXTERNS);
   }
 
   private SymbolTable createSymbolTable(String input, String externsCode) {