Lookup the superclass/subclass for goog.inherits by property

This fixes some cases where the superClass_ property was not defined on the subclass

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

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

@@ -41,6 +41,7 @@
 import com.google.javascript.rhino.JSDocInfo;
 import com.google.javascript.rhino.JSTypeExpression;
 import com.google.javascript.rhino.Node;
+import com.google.javascript.rhino.QualifiedName;
 import com.google.javascript.rhino.Token;
 import com.google.javascript.rhino.jstype.EnumType;
 import com.google.javascript.rhino.jstype.FunctionType;
@@ -2362,10 +2363,12 @@ private void checkCallConventions(NodeTraversal t, Node n) {
         compiler.getCodingConvention().getClassesDefinedByCall(n);
     TypedScope scope = t.getTypedScope();
     if (relationship != null) {
-      ObjectType superClass = TypeValidator.getInstanceOfCtor(
-          scope.getVar(relationship.superclassName));
-      ObjectType subClass = TypeValidator.getInstanceOfCtor(
-          scope.getVar(relationship.subclassName));
+      ObjectType superClass =
+          TypeValidator.getInstanceOfCtor(
+              scope.lookupQualifiedName(QualifiedName.of(relationship.superclassName)));
+      ObjectType subClass =
+          TypeValidator.getInstanceOfCtor(
+              scope.lookupQualifiedName(QualifiedName.of(relationship.subclassName)));
       if (relationship.type == SubclassType.INHERITS
           && superClass != null
           && !superClass.isEmptyType()

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

@@ -191,21 +191,12 @@ class TypeValidator implements Serializable {
             typeRegistry.getNativeObjectType(JSTypeNative.ASYNC_ITERATOR_TYPE));
   }
 
-  /**
-   * Utility function for getting a function type from a var.
-   */
-  static FunctionType getFunctionType(@Nullable TypedVar v) {
-    JSType t = v == null ? null : v.getType();
-    ObjectType o = t == null ? null : t.dereference();
-    return JSType.toMaybeFunctionType(o);
-  }
-
-  /**
-   * Utility function for getting an instance type from a var pointing
-   * to the constructor.
-   */
-  static ObjectType getInstanceOfCtor(@Nullable TypedVar v) {
-    FunctionType ctor = getFunctionType(v);
+  /** Utility function that attempts to get an instance type from a potential constructor type */
+  static ObjectType getInstanceOfCtor(@Nullable JSType t) {
+    if (t == null) {
+      return null;
+    }
+    FunctionType ctor = JSType.toMaybeFunctionType(t.dereference());
     if (ctor != null && ctor.isConstructor()) {
       return ctor.getInstanceType();
     }

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

@@ -21,10 +21,12 @@
 import com.google.common.collect.Iterables;
 import com.google.javascript.rhino.JSDocInfo;
 import com.google.javascript.rhino.Node;
+import com.google.javascript.rhino.QualifiedName;
 import com.google.javascript.rhino.jstype.JSType;
 import com.google.javascript.rhino.jstype.ObjectType;
 import com.google.javascript.rhino.jstype.StaticTypedScope;
 import com.google.javascript.rhino.jstype.StaticTypedSlot;
+import javax.annotation.Nullable;
 
 /**
  * TypedScope contains information about variables and their types. Scopes can be nested, a scope
@@ -188,4 +190,28 @@ public JSDocInfo getJsdocOfTypeDeclaration(String typeName) {
     StaticTypedSlot slot = getSlot(typeName);
     return slot == null ? null : slot.getJSDocInfo();
   }
+
+  /**
+   * Looks up a given qualified name in the scope. if that fails, looks up the component properties
+   * off of any owner types that are in scope.
+   *
+   * <p>This is always more or equally expensive as calling getVar(String name), so should only be
+   * used when necessary.
+   */
+  @Nullable
+  public JSType lookupQualifiedName(QualifiedName qname) {
+    TypedVar slot = getVar(qname.join());
+    if (slot != null && !slot.isTypeInferred()) {
+      JSType type = slot.getType();
+      if (type != null && !type.isUnknownType()) {
+        return type;
+      }
+    } else if (!qname.isSimple()) {
+      JSType type = lookupQualifiedName(qname.getOwner());
+      if (type != null) {
+        return type.findPropertyType(qname.getComponent());
+      }
+    }
+    return null;
+  }
 }

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

@@ -1977,7 +1977,7 @@ private Node getDefinitionNode(QualifiedName qname) {
         TypedVar var = currentScope.getVar(qname.getComponent());
         return var != null ? var.getNameNode() : null;
       }
-      ObjectType parent = ObjectType.cast(lookupQualifiedName(qname.getOwner()));
+      ObjectType parent = ObjectType.cast(currentScope.lookupQualifiedName(qname.getOwner()));
       return parent != null ? parent.getPropertyDefSite(qname.getComponent()) : null;
     }
 
@@ -2007,7 +2007,7 @@ private JSType getDeclaredRValueType(@Nullable Node lValue, Node rValue) {
 
       // If rValue is a name, try looking it up in the current scope.
       if (rValue.isQualifiedName()) {
-        return lookupQualifiedName(rValue.getQualifiedNameObject());
+        return currentScope.lookupQualifiedName(rValue.getQualifiedNameObject());
       }
 
       // Check for simple invariant operations, such as "!x" or "+x" or "''+x"
@@ -2024,11 +2024,10 @@ private JSType getDeclaredRValueType(@Nullable Node lValue, Node rValue) {
       }
 
       if (rValue.isNew() && rValue.getFirstChild().isQualifiedName()) {
-        JSType targetType = lookupQualifiedName(rValue.getFirstChild().getQualifiedNameObject());
+        JSType targetType =
+            currentScope.lookupQualifiedName(rValue.getFirstChild().getQualifiedNameObject());
         if (targetType != null) {
-          FunctionType fnType = targetType
-              .restrictByNotNullOrUndefined()
-              .toMaybeFunctionType();
+          FunctionType fnType = targetType.restrictByNotNullOrUndefined().toMaybeFunctionType();
           if (fnType != null && fnType.hasInstanceType()) {
             return fnType.getInstanceType();
           }
@@ -2058,25 +2057,6 @@ private JSType getDeclaredRValueType(@Nullable Node lValue, Node rValue) {
       return null;
     }
 
-    private JSType lookupQualifiedName(QualifiedName qname) {
-      TypedVar slot = currentScope.getVar(qname.join());
-      if (slot != null && !slot.isTypeInferred()) {
-        JSType type = slot.getType();
-        if (type != null && !type.isUnknownType()) {
-          return type;
-        }
-      } else if (!qname.isSimple()) {
-        JSType type = lookupQualifiedName(qname.getOwner());
-        // NOTE: The scope only contains declared types at this
-        // point so any property we find is a value type
-        // to look up properties on.
-        if (type != null) {
-          return type.findPropertyType(qname.getComponent());
-        }
-      }
-      return null;
-    }
-
     /**
      * Look for class-defining calls.
      * Because JS has no 'native' syntax for defining classes,
@@ -2087,9 +2067,11 @@ void checkForClassDefiningCalls(Node n) {
           codingConvention.getClassesDefinedByCall(n);
       if (relationship != null) {
         ObjectType superClass =
-            TypeValidator.getInstanceOfCtor(currentScope.getVar(relationship.superclassName));
+            TypeValidator.getInstanceOfCtor(
+                currentScope.lookupQualifiedName(QualifiedName.of(relationship.superclassName)));
         ObjectType subClass =
-            TypeValidator.getInstanceOfCtor(currentScope.getVar(relationship.subclassName));
+            TypeValidator.getInstanceOfCtor(
+                currentScope.lookupQualifiedName(QualifiedName.of(relationship.subclassName)));
         if (superClass != null && subClass != null) {
           // superCtor and subCtor might be structural constructors
           // (like {function(new:Object)}) so we need to resolve them back

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

@@ -5059,6 +5059,91 @@ public void testGoodExtends14() {
         "Property foo never defined on OldType.prototype");
   }
 
+  @Test
+  public void testGoodExtends_withAliasOfSuperclass() {
+    testTypesWithCommonExterns(
+        CLOSURE_DEFS
+            + lines(
+                "/** @constructor */ const OldType = function () {};",
+                "const OldTypeAlias = OldType;",
+                "",
+                "/**",
+                "  * @constructor",
+                "  * @extends {OldTypeAlias}",
+                "  */",
+                "function NewType() {};",
+                // Verify that we recognize the inheritance even when goog.inherits references
+                // OldTypeAlias, not OldType.
+                "goog.inherits(NewType, OldTypeAlias);",
+                "NewType.prototype.method = function() {",
+                "  NewType.superClass_.foo.call(this);",
+                "};"),
+        "Property foo never defined on OldType.prototype");
+  }
+
+  @Test
+  public void testBadExtends_withAliasOfSuperclass() {
+    testTypesWithCommonExterns(
+        CLOSURE_DEFS
+            + lines(
+                "const ns = {};",
+                "/** @constructor */ ns.OldType = function () {};",
+                "const nsAlias = ns;",
+                "",
+                "/**",
+                "  * @constructor",
+                "  * // no @extends here, NewType should not have a goog.inherits",
+                "  */",
+                "function NewType() {};",
+                // Verify that we recognize the inheritance even when goog.inherits references
+                // nsAlias.OldType, not ns.OldType.
+                "goog.inherits(NewType, ns.OldType);"),
+        "Missing @extends tag on type NewType");
+  }
+
+  @Test
+  public void testBadExtends_withNamespacedAliasOfSuperclass() {
+    testTypesWithCommonExterns(
+        CLOSURE_DEFS
+            + lines(
+                "const ns = {};",
+                "/** @constructor */ ns.OldType = function () {};",
+                "const nsAlias = ns;",
+                "",
+                "/**",
+                "  * @constructor",
+                "  * // no @extends here, NewType should not have a goog.inhertis",
+                "  */",
+                "function NewType() {};",
+                // Verify that we recognize the inheritance even when goog.inherits references
+                // nsAlias.OldType, not ns.OldType.
+                "goog.inherits(NewType, nsAlias.OldType);"),
+        "Missing @extends tag on type NewType");
+  }
+
+  @Test
+  public void testGoodExtends_withNamespacedAliasOfSuperclass() {
+    testTypesWithCommonExterns(
+        CLOSURE_DEFS
+            + lines(
+                "const ns = {};",
+                "/** @constructor */ ns.OldType = function () {};",
+                "const nsAlias = ns;",
+                "",
+                "/**",
+                "  * @constructor",
+                "  * @extends {nsAlias.OldType}",
+                "  */",
+                "function NewType() {};",
+                // Verify that we recognize the inheritance even when goog.inherits references
+                // nsAlias.OldType, not ns.OldType.
+                "goog.inherits(NewType, nsAlias.OldType);",
+                "NewType.prototype.method = function() {",
+                "  NewType.superClass_.foo.call(this);",
+                "};"),
+        "Property foo never defined on ns.OldType.prototype");
+  }
+
   @Test
   public void testGoodExtends15() {
     testTypes(