Adds typing support for this and super in static methods.

The main changes are in `TypedScope` (to generate the type for `super`) and `TypedScopeCreator` (to determine the type of `this` for static methods).

This changes applies to all functions declared as properties on constructors and interfaces. That includes ES5 constructors. However, this does not mean any kind of support for class side inheritance on ES5 constructors.

The majority of the changes are test updates to accommodate the new type information.

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

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

@@ -764,51 +764,32 @@ private void traverseSuper(Node superNode) {
       superNode.setJSType(unknownType);
       return;
     }
-    Node root = scope.getRootNode();
-    JSType jsType = root.getJSType();
-    FunctionType functionType = jsType != null ? jsType.toMaybeFunctionType() : null;
-    ObjectType superNodeType = unknownType;
-    Node context = superNode.getParent();
-    // NOTE: we currently transpile subclass constructors to use "super.apply", which is not
-    // actually valid ES6.  For now, provide a special case to support this, but it should be
-    // removed once class transpilation is after type checking.
-    if (context.isCall()) {
-      // Call the superclass constructor.
-      if (functionType != null && functionType.isConstructor()) {
-        FunctionType superCtor = functionType.getSuperClassConstructor();
-        if (superCtor != null) {
-          superNodeType = superCtor;
-        }
-      }
-    } else if (context.isGetProp() || context.isGetElem()) {
-      // TODO(sdh): once getTypeOfThis supports statics, we can get rid of this branch, as well as
-      // the vanilla function search at the top and just return functionScope.getVar("super").
-      if (root.getParent().isStaticMember()) {
-        // Since the root is a static member, we're guaranteed that the parent scope is a class.
-        Node classNode = scope.getParent().getRootNode();
-        checkState(classNode.isClass());
-        FunctionType thisCtor = JSType.toMaybeFunctionType(classNode.getJSType());
-        if (thisCtor != null) {
-          FunctionType superCtor = thisCtor.getSuperClassConstructor();
-          if (superCtor != null) {
-            superNodeType = superCtor;
-          }
-        }
-      } else if (functionType != null) {
-        // Refer to a superclass instance property.
-        ObjectType thisInstance = ObjectType.cast(functionType.getTypeOfThis());
-        if (thisInstance != null) {
-          FunctionType superCtor = thisInstance.getSuperClassConstructor();
-          if (superCtor != null) {
-            ObjectType superInstance = superCtor.getInstanceType();
-            if (superInstance != null) {
-              superNodeType = superInstance;
-            }
-          }
+
+    FunctionType enclosingFunctionType =
+        JSType.toMaybeFunctionType(scope.getRootNode().getJSType());
+    ObjectType superNodeType = null;
+
+    switch (superNode.getParent().getToken()) {
+      case CALL:
+        // Inside a constructor, `super` may have two different types. Calls to `super()` use the
+        // super-ctor type, while property accesses use the super-instance type. `Scopes` are only
+        // aware of the latter case.
+        if (enclosingFunctionType != null && enclosingFunctionType.isConstructor()) {
+          superNodeType = enclosingFunctionType.getSuperClassConstructor();
         }
-      }
+        break;
+
+      case GETELEM:
+      case GETPROP:
+        superNodeType = ObjectType.cast(functionScope.getSlot("super").getType());
+        break;
+
+      default:
+        throw new IllegalStateException(
+            "Unexpected parent of SUPER: " + superNode.getParent().toStringTree());
     }
-    superNode.setJSType(superNodeType);
+
+    superNode.setJSType(superNodeType != null ? superNodeType : unknownType);
   }
 
   private void traverseNewTarget(Node newTargetNode) {

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

@@ -21,6 +21,7 @@
 import com.google.common.collect.Iterables;
 import com.google.javascript.rhino.JSDocInfo;
 import com.google.javascript.rhino.Node;
+import com.google.javascript.rhino.jstype.FunctionType;
 import com.google.javascript.rhino.jstype.JSType;
 import com.google.javascript.rhino.jstype.ObjectType;
 import com.google.javascript.rhino.jstype.StaticTypedScope;
@@ -146,16 +147,33 @@ TypedVar makeImplicitVar(ImplicitVar var) {
   }
 
   private JSType getImplicitVarType(ImplicitVar var) {
-    if (var == ImplicitVar.ARGUMENTS) {
-      // Look for an extern named "arguments" and use its type if available.
-      // TODO(sdh): consider looking for "Arguments" ctor rather than "arguments" var: this could
-      // allow deleting the variable, which doesn't really belong in externs in the first place.
-      TypedVar globalArgs = getGlobalScope().getVar(Var.ARGUMENTS);
-      return globalArgs != null && globalArgs.isExtern()
-          ? globalArgs.getType()
-          : null;
+    switch (var) {
+      case ARGUMENTS:
+        // Look for an extern named "arguments" and use its type if available.
+        // TODO(sdh): consider looking for "Arguments" ctor rather than "arguments" var: this could
+        // allow deleting the variable, which doesn't really belong in externs in the first place.
+        TypedVar globalArgs = getGlobalScope().getVar(Var.ARGUMENTS);
+        return globalArgs != null && globalArgs.isExtern() ? globalArgs.getType() : null;
+
+      case THIS:
+        return getTypeOfThis();
+
+      case SUPER:
+        // Inside a constructor, `super` may have two different types. Calls to `super()` use the
+        // super-ctor type, while property accesses use the super-instance type. This logic always
+        // returns the latter case.
+        ObjectType receiverType = ObjectType.cast(getTypeOfThis());
+        if (receiverType == null) {
+          return null;
+        } else if (receiverType.isInstanceType()) {
+          FunctionType superclassCtor = receiverType.getSuperClassConstructor();
+          return superclassCtor == null ? null : superclassCtor.getInstanceType();
+        } else {
+          return receiverType.getImplicitPrototype();
+        }
     }
-    return getTypeOfThis();
+
+    throw new AssertionError();
   }
 
   /**

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

@@ -1685,18 +1685,29 @@ private FunctionType createFunctionTypeFromNodes(
       }
 
       // Infer the context type.
+      JSType fallbackReceiverType = null;
       if (ownerType != null
           && ownerType.isFunctionPrototypeType()
           && ownerType.getOwnerFunction().hasInstanceType()) {
-        builder.inferThisType(info, ownerType.getOwnerFunction().getInstanceType());
+        fallbackReceiverType = ownerType.getOwnerFunction().getInstanceType();
+      } else if (ownerType != null
+          && ownerType.isFunctionType()
+          && ownerType.toMaybeFunctionType().hasInstanceType()
+          && lvalueNode != null
+          && lvalueNode.isStaticMember()) {
+        // Limit this case to members of ctors and interfaces decalared using `static`. Most
+        // namespaces, like object literals, are assumed to declare free functions, so we exclude
+        // them. Additionally, methods *assigned* to a ctor, especially an ES5 ctor, were never
+        // designed with static polymorphism in mind, so excluding them preserves their assumptions.
+        fallbackReceiverType = ownerType;
       } else if (ownerNode != null && ownerNode.isThis()) {
-        // If we have a 'this' node, use the scope type.
-        builder.inferThisType(info, currentScope.getTypeOfThis());
-      } else {
-        builder.inferThisType(info);
+        fallbackReceiverType = currentScope.getTypeOfThis();
       }
 
-      return builder.inferParameterTypes(parametersNode, info).buildAndRegister();
+      return builder
+          .inferThisType(info, fallbackReceiverType)
+          .inferParameterTypes(parametersNode, info)
+          .buildAndRegister();
     }
 
     /**

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

@@ -248,7 +248,7 @@ public void createSuperForFunction() {
                 "class A {}",
                 "class B extends A {", //
                 "  method() {",
-                "    super;", // created `super` should match this one
+                "    super.method();", // created `super` should match this one
                 "  }",
                 "}",
                 ""));
@@ -268,7 +268,8 @@ public void createSuperForFunction() {
         methodFunction
             .getLastChild() // method function body
             .getFirstChild() // expr_result
-            .getOnlyChild(); // super
+            .getOnlyChild() // call "method"
+            .getFirstFirstChild(); // super
 
     Node newSuper = astFactory.createSuperForFunction(methodFunction);
     assertNode(newSuper).isEqualTo(existingSuper);

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

@@ -929,15 +929,13 @@ public void testRestrictedCall2() {
         "/** @param {*} a */\n" +
         "C.m = function(a){}\n";
 
-    testNoWarning(
-        code + "C.m(1);");
+    testNoWarning(code + "C.m(1);");
 
     testWarning(code + "C.m('str');", CheckConformance.CONFORMANCE_VIOLATION);
 
-    testNoWarning(
-        code + "C.m.call(this, 1);");
+    testNoWarning(code + "C.m.call(C, 1);");
 
-    testWarning(code + "C.m.call(this, 'str');", CheckConformance.CONFORMANCE_VIOLATION);
+    testWarning(code + "C.m.call(C, 'str');", CheckConformance.CONFORMANCE_VIOLATION);
   }
 
   @Test

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

@@ -3014,26 +3014,45 @@ public void testEs6ClassSideInheritedMethods_areDisambiguated() {
 
   @Test
   public void testEs6ClassSideInheritedMethods_referencedWithThis_areDisambiguated() {
-    // TODO(b/117437011): compiler should disambiguate `method` but can't because `this` is unknown
-    // in static methods
-    testSame(
+    test(
         lines(
             "class Foo {",
             "  static method() {}",
             "  static useMethod() {",
-            "    this.method();", // this could refer to either Foo.method or SubFoo.method
+            "    this.method();",
             "  }",
             "}",
             "class SubFoo extends Foo {",
             "  static method() {}",
             "}",
+            "",
             "class Bar {",
             "  static method() {}",
             "}",
+            "",
             "SubFoo.useMethod();",
             "Foo.method();",
             "SubFoo.method();",
-            "Bar.method();"));
+            "Bar.method();"),
+        lines(
+            "class Foo {",
+            "  static _typeof_Foo_$method() {}",
+            "  static useMethod() {",
+            "    this._typeof_Foo_$method();",
+            "  }",
+            "}",
+            "class SubFoo extends Foo {",
+            "  static _typeof_Foo_$method() {}",
+            "}",
+            "",
+            "class Bar {",
+            "  static _typeof_Bar_$method() {}",
+            "}",
+            "",
+            "SubFoo.useMethod();",
+            "Foo._typeof_Foo_$method();",
+            "SubFoo._typeof_Foo_$method();",
+            "Bar._typeof_Bar_$method();"));
   }
 
   @Test

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

@@ -118,6 +118,7 @@ public void exportClassAsSymbolAndMethodAsProperty() {
             "};",
             "/**",
             " * @return {undefined}",
+            " * @this {(typeof a.b.c)}",
             " */",
             "foobar.exportedStaticMethod = function() {",
             "};",

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

@@ -1590,14 +1590,16 @@ public void testAmbiguousDefinitionsAllPropagationTypes() {
 
   @Test
   public void testAmbiguousDefinitionsCallWithThis() {
-    String source = CompilerTypeTestCase.CLOSURE_DEFS + lines(
-        "var globalVar = 1;",
-        "A.modifiesThis = function() { this.x = 5; };",
-        "/**@constructor*/function Constructor() { Constructor.modifiesThis.call(this); };",
-        "Constructor.modifiesThis = function() {};",
-        "new Constructor();",
-        "A.modifiesThis();"
-    );
+    String source =
+        CompilerTypeTestCase.CLOSURE_DEFS
+            + lines(
+                "A.modifiesThis = function() { this.x = 5; };",
+                "B.modifiesThis = function() {};",
+                "",
+                "/** @constructor */ function Constructor() { B.modifiesThis.call(this); };",
+                "",
+                "new Constructor();",
+                "A.modifiesThis();");
 
     // Can't tell which modifiesThis is being called so it assumes both.
     assertPureCallsMarked(source, ImmutableList.of("Constructor"));

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

@@ -581,8 +581,7 @@ public void testInnerSuperCallStaticEs2015Out() {
     Node fakeSuperDotM = wrapperArrowFunction.getLastChild();
     assertNode(fakeSuperDotM).hasJSTypeThat().isEqualTo(classAPropertyMType);
     Node fakeSuperNode = fakeSuperDotM.getFirstChild();
-    // TODO(b/118174876): We currently type `super` as unknown in static methods.
-    assertNode(fakeSuperNode).isCall().hasJSTypeThat().toStringIsEqualTo("?");
+    assertNode(fakeSuperNode).isCall().hasJSTypeThat().toStringIsEqualTo("(typeof A)");
     assertNode(fakeSuperNode.getFirstChild()).matchesQualifiedName("Object.getPrototypeOf");
   }
 

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

@@ -3486,8 +3486,8 @@ public void testStaticMethod_overriddenInBody_withSupertype_isBad() {
         lines(
             "mismatch of the method property type and the type of the property it overrides "
                 + "from supertype (typeof Base)",
-            "original: function((number|string)): undefined",
-            "override: function(string): undefined"));
+            "original: function(this:(typeof Base), (number|string)): undefined",
+            "override: function(this:(typeof Sub), string): undefined"));
   }
 
   @Test
@@ -3504,8 +3504,8 @@ public void testStaticMethod_overriddenInBody_withSupertype_fromInline_isBad() {
         lines(
             "mismatch of the method property type and the type of the property it overrides "
                 + "from supertype (typeof Base)",
-            "original: function((number|string)): undefined",
-            "override: function(string): undefined"));
+            "original: function(this:(typeof Base), (number|string)): undefined",
+            "override: function(this:(typeof Sub), string): undefined"));
   }
 
   @Test
@@ -3544,7 +3544,7 @@ public void testStaticMethod_overriddenOutsideBody_withSupertype_isBad() {
         lines(
             "mismatch of the method property type and the type of the property it overrides "
                 + "from supertype (typeof Base)",
-            "original: function((number|string)): undefined",
+            "original: function(this:(typeof Base), (number|string)): undefined",
             "override: function(string): undefined"));
   }
 
@@ -3637,7 +3637,7 @@ public void testStaticMethod_onNamespacedType_overridden_withNonSubtype_isBad()
         lines(
             "mismatch of the method property type and the type of the property it overrides "
                 + "from supertype (typeof ns.Base)",
-            "original: function(string): undefined",
+            "original: function(this:(typeof ns.Base), string): undefined",
             "override: function(number): undefined"));
   }
 
@@ -4064,16 +4064,15 @@ public void testClassTypeOfThisInMethod() {
   public void testClassTypeOfThisInStaticMethod() {
     testTypes(
         lines(
-            "class Foo {",
+            "class Foo {", //
             "  static foo() {",
             "    var /** null */ foo = this;",
             "  }",
-            "}"));
-        // TODO(sdh): Should be an error, but wait on it since it's a new warning.
-        // lines(
-        //     "initializing variable",
-        //     "found   : function(new:Foo): undefined",
-        //     "required: null"));
+            "}"),
+        lines(
+            "initializing variable", //
+            "found   : (typeof Foo)",
+            "required: null"));
   }
 
   @Test

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

@@ -3855,10 +3855,11 @@ public void testStubFunctionDeclaration2() {
   }
 
   @Test
-  public void testStubFunctionDeclaration3() {
+  public void testStubFunctionDeclaration_static_onEs5Class() {
     testFunctionType(
-        "/** @constructor */ function f() {};" +
-        "/** @return {undefined} */ f.foo;",
+        lines(
+            "/** @constructor */ function f() {};", //
+            "/** @return {undefined} */ f.foo;"),
         "f.foo",
         "function(): undefined");
   }
@@ -8453,11 +8454,12 @@ public void testThis8() {
   }
 
   @Test
-  public void testThis9() {
-    // In A.bar, the type of {@code this} is unknown.
-    testTypes("/** @constructor */function A(){};" +
-        "A.prototype.foo = 3;" +
-        "/** @return {string} */ A.bar = function() { return this.foo; };");
+  public void testTypeOfThis_inStaticMethod_onEs5Ctor_isUnknown() {
+    testTypes(
+        lines(
+            "/** @constructor */function A(){};",
+            "A.foo = 3;",
+            "/** @return {string} */ A.bar = function() { return this.foo; };"));
   }
 
   @Test