[NTI] When Bar extends Foo, the prototype object of Bar.prototype sho…

…uld be a Foo instead of Foo.prototype.

In OTI this is accomplished by using PrototypeObjectType.
Fixes issue with disambiguation.

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

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

@@ -168,7 +168,7 @@ Map<String, String> getRenamingMap() {
   private int getIntForType(TypeI type) {
     // Templatized types don't exist at runtime, so collapse to raw type
     if (type != null && type.isGenericObjectType()) {
-      type = type.toMaybeObjectType().getPrototypeObject().getOwnerFunction().getInstanceType();
+      type = type.toMaybeObjectType().getRawType();
     }
     if (intForType.containsKey(type)) {
       return intForType.get(type).intValue();

src/com/google/javascript/jscomp/newtypes/JSType.java

@@ -2041,19 +2041,8 @@ public final FunctionTypeI getSuperClassConstructor() {
   @Override
   public final JSType getPrototypeObject() {
     checkState(this.isSingletonObj());
-    JSType proto = getNominalTypeIfSingletonObj().getPrototypeObject();
-    if (this.equals(proto)) {
-      // In JS's dynamic semantics, the only object without a __proto__ is
-      // Object.prototype, but it's not representable in NTI.
-      // Object.prototype is the only case where we are equal to our own prototype.
-      // In this case, we should return null.
-      Preconditions.checkState(
-          isBuiltinObjectPrototype(),
-          "Failed to reach Object.prototype in prototype chain, unexpected self-link found at %s",
-          this);
-      return null;
-    }
-    return proto;
+    ObjectType proto = getObjTypeIfSingletonObj().getPrototypeObject();
+    return proto != null ? fromObjectType(proto) : null;
   }
 
   @Override
@@ -2101,11 +2090,6 @@ public final boolean isAmbiguousObject() {
     return obj != null && obj.isAmbiguousObject();
   }
 
-  final boolean isBuiltinObjectPrototype() {
-    ObjectType obj = getObjTypeIfSingletonObj();
-    return obj != null && obj.getNominalType().isBuiltinObject() && obj.isPrototypeObject();
-  }
-
   @Override
   public final boolean isLiteralObject() {
     return isSingletonObj() && getNominalTypeIfSingletonObj().isLiteralObject();

src/com/google/javascript/jscomp/newtypes/ObjectType.java

@@ -37,6 +37,7 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.TreeSet;
+import javax.annotation.Nullable;
 
 /**
  * {@link JSType}s include a possibly-empty set of ObjectType instances,
@@ -209,6 +210,39 @@ boolean isNamespace() {
     return this.ns != null;
   }
 
+  private boolean isBuiltinObjectPrototype() {
+    return this.nominalType.isBuiltinObject() && isPrototypeObject();
+  }
+
+  /**
+   * Returns the prototype of this object type. For Object.prototype it returns null.
+   * When Bar extends Foo, the prototype of Bar.prototype is the canonical Foo instance. (This is
+   * accomplished in OTI by using the special type PrototypeObjectType.)
+   * As a result, this method may return a type X for which isPrototypeObject is false, i.e.,
+   * a type that has no owner function.
+   */
+  @Nullable
+  ObjectType getPrototypeObject() {
+    ObjectType proto;
+    if (isPrototypeObject() && !isBuiltinObjectPrototype()) {
+      proto = this.nominalType.getInstanceAsObjectType();
+    } else {
+      proto = this.nominalType.getPrototypeObject().getObjTypeIfSingletonObj();
+    }
+    if (this.equals(proto)) {
+      // In JS's dynamic semantics, the only object without a __proto__ is
+      // Object.prototype, but it's not representable in NTI.
+      // Object.prototype is the only case where we are equal to our own prototype.
+      // In this case, we should return null.
+      Preconditions.checkState(
+          isBuiltinObjectPrototype(),
+          "Failed to reach Object.prototype in prototype chain, unexpected self-link found at %s",
+          this);
+      return null;
+    }
+    return proto;
+  }
+
   boolean isPrototypeObject() {
     return getOwnerFunction() != null;
   }

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

@@ -1041,4 +1041,38 @@ public void testUnannotatedConstructorsDontCrash() {
         "function Bar() {}",
         "Bar.prototype.a;"));
   }
+
+  public void testGenericPrototypeObject() {
+    String js = LINE_JOINER.join(
+        "/**",
+        " * @constructor",
+        " * @template T",
+        " */",
+        "function Foo() {",
+        "  this.a = 1;",
+        "}",
+        "/** @constructor @extends {Foo<number>} */",
+        "function Bar() {}",
+        "/** @constructor */",
+        "function Baz() {",
+        "  this.b = 2;",
+        "}");
+
+    String output = LINE_JOINER.join(
+        "/**",
+        " * @constructor",
+        " * @template T",
+        " */",
+        "function Foo() {",
+        "  this.a = 1;",
+        "}",
+        "/** @constructor @extends {Foo<number>} */",
+        "function Bar() {}",
+        "/** @constructor */",
+        "function Baz() {",
+        "  this.a = 2;",
+        "}");
+
+    test(js, output);
+  }
 }

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

@@ -197,6 +197,40 @@ public void testPrototypeAndInstance4() {
     testSets(js, js, "{a=[[Foo.prototype]]}");
   }
 
+  public void testPrototypeAndInstance5() {
+    String js = LINE_JOINER.join(
+        "/** @constructor */",
+        "function Foo() {",
+        "  this.a = 1;",
+        "}",
+        "/** @constructor @extends {Foo} */",
+        "function Bar() {",
+        "  this.a = 2;",
+        "}",
+        "/** @constructor */",
+        "function Baz() {",
+        "  this.a = 3;",
+        "}",
+        "var x = (new Bar).a;");
+
+    String output = LINE_JOINER.join(
+        "/** @constructor */",
+        "function Foo() {",
+        "  this.Foo$a = 1;",
+        "}",
+        "/** @constructor @extends {Foo} */",
+        "function Bar() {",
+        "  this.Foo$a = 2;",
+        "}",
+        "/** @constructor */",
+        "function Baz() {",
+        "  this.Baz$a = 3;",
+        "}",
+        "var x = (new Bar).Foo$a;");
+
+    test(js, output);
+  }
+
   public void testTwoTypes1() {
     String js = ""
         + "/** @constructor */ function Foo() {}\n"