Simplify NominalTypeBuilder to no longer need any Runnables.

This is possibly being a little bit looser in NTI, using instance types in place of prototype objects when the latter are unavailable.

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

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

@@ -54,9 +54,9 @@ public String getSingletonGetterClassName(Node callNode) {
 
   @Override
   public void applySingletonGetter(NominalTypeBuilder classType, FunctionTypeI getterType) {
-    Node defSite = ((FunctionTypeI) classType.constructor().toTypeI()).getSource();
-    classType.constructor().declareProperty("getInstance", getterType, defSite);
-    classType.constructor().declareProperty("instance_", classType.instance().toTypeI(), defSite);
+    Node defSite = classType.constructor().getSource();
+    classType.declareConstructorProperty("getInstance", getterType, defSite);
+    classType.declareConstructorProperty("instance_", classType.instance(), defSite);
   }
 
   @Override

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

@@ -76,22 +76,17 @@ public void applySubclassRelationship(
       final NominalTypeBuilder parent, final NominalTypeBuilder child, SubclassType type) {
     super.applySubclassRelationship(parent, child, type);
     if (type == SubclassType.INHERITS) {
-      final FunctionTypeI childCtor = (FunctionTypeI) child.constructor().toTypeI();
-      child.beforeFreeze(new Runnable() {
-        @Override
-        public void run() {
-          child.constructor().declareProperty(
-              "superClass_", parent.prototype().toTypeI(), childCtor.getSource());
-        }
-      }, parent);
+      final FunctionTypeI childCtor = child.constructor();
+      child.declareConstructorProperty(
+          "superClass_", parent.prototypeOrInstance(), childCtor.getSource());
       // Notice that constructor functions do not need to be covariant on the superclass.
       // So if G extends F, new G() and new F() can accept completely different argument
       // types, but G.prototype.constructor needs to be covariant on F.prototype.constructor.
       // To get around this, we just turn off type-checking on arguments and return types
       // of G.prototype.constructor.
       FunctionTypeI qmarkCtor =
           childCtor.toBuilder().withUnknownReturnType().withNoParameters().build();
-      child.prototype().declareProperty("constructor", qmarkCtor, childCtor.getSource());
+      child.declarePrototypeProperty("constructor", qmarkCtor, childCtor.getSource());
     }
   }
 
@@ -320,9 +315,9 @@ public String getSingletonGetterClassName(Node callNode) {
 
   @Override
   public void applySingletonGetter(NominalTypeBuilder classType, FunctionTypeI getterType) {
-    Node defSite = ((FunctionTypeI) classType.constructor().toTypeI()).getSource();
-    classType.constructor().declareProperty("getInstance", getterType, defSite);
-    classType.constructor().declareProperty("instance_", classType.instance().toTypeI(), defSite);
+    Node defSite = classType.constructor().getSource();
+    classType.declareConstructorProperty("getInstance", getterType, defSite);
+    classType.declareConstructorProperty("instance_", classType.instance(), defSite);
   }
 
   @Override

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

@@ -296,8 +296,6 @@ public class GlobalTypeInfoCollector implements CompilerPass {
   // Keyed on RawNominalTypes and property names
   private HashBasedTable<RawNominalType, String, PropertyDef> propertyDefs =
       HashBasedTable.create();
-  private final NominalTypeBuilderNti.LateProperties lateProps =
-      new NominalTypeBuilderNti.LateProperties();
   private final Set<RawNominalType> inProgressFreezes = new LinkedHashSet<>();
   private final GlobalTypeInfo globalTypeInfo;
   private final OrderedExterns orderedExterns;
@@ -541,11 +539,6 @@ private void checkAndFreezeNominalType(RawNominalType rawType) {
       }
     }
 
-    for (RawNominalType prerequisite : lateProps.prerequisites(rawType)) {
-      checkAndFreezeNominalType(prerequisite);
-    }
-    lateProps.defineProperties(rawType);
-
     Multimap<String, DeclaredFunctionType> propMethodTypesToProcess = LinkedHashMultimap.create();
     Multimap<String, JSType> propTypesToProcess = LinkedHashMultimap.create();
     // Collect inherited types for extended classes
@@ -1722,8 +1715,8 @@ private void applySubclassRelationship(SubclassRelationship rel) {
       if (superClass != null && superClass.getConstructorFunction() != null
           && subClass != null && subClass.getConstructorFunction() != null) {
         convention.applySubclassRelationship(
-            new NominalTypeBuilderNti(lateProps, superClass),
-            new NominalTypeBuilderNti(lateProps, subClass),
+            new NominalTypeBuilderNti(superClass.getAsNominalType()),
+            new NominalTypeBuilderNti(subClass.getAsNominalType()),
             rel.type);
       }
     }
@@ -1735,7 +1728,7 @@ private void applySingletonGetter(String className) {
         JSType getInstanceType =
             new FunctionTypeBuilder(getCommonTypes()).addRetType(instanceType).buildType();
         convention.applySingletonGetter(
-            new NominalTypeBuilderNti(lateProps, rawType), getInstanceType);
+            new NominalTypeBuilderNti(rawType.getAsNominalType()), getInstanceType);
       }
     }
 
@@ -1767,12 +1760,12 @@ private void applyDelegateRelationship(DelegateRelationship rel) {
                 .addNominalType(delegateProxy.getInstanceAsJSType())
                 .buildFunction());
         convention.applyDelegateRelationship(
-            new NominalTypeBuilderNti(lateProps, delegateSuper),
-            new NominalTypeBuilderNti(lateProps, delegateBase),
-            new NominalTypeBuilderNti(lateProps, delegator),
+            new NominalTypeBuilderNti(delegateSuper.getAsNominalType()),
+            new NominalTypeBuilderNti(delegateBase.getAsNominalType()),
+            new NominalTypeBuilderNti(delegator.getAsNominalType()),
             delegateProxy.getInstanceAsJSType(),
             findDelegate);
-        delegateProxies.add(new NominalTypeBuilderNti(lateProps, delegateProxy));
+        delegateProxies.add(new NominalTypeBuilderNti(delegateProxy.getAsNominalType()));
       }
     }
 
@@ -2163,18 +2156,18 @@ private void visitOtherPropertyDeclaration(Node getProp) {
         return;
       }
       JSType recvType = simpleInferExprType(recv);
-      if (recvType == null) {
-        // Might still be worth recording a property, e.g. on a function.
-        PropertyDef def = findPropertyDef(recv);
-        if (def != null) {
-          JSType type =
-              getProp.getNext() != null
-                  ? simpleInferExprType(getProp.getNext())
-                  : getCommonTypes().UNKNOWN;
-          if (type != null) {
-            def.addProperty(recv.getNext().getString(), type);
-          }
+      // Might still be worth recording a property, e.g. on a function.
+      PropertyDef def = findPropertyDef(recv);
+      if (def != null) {
+        JSType type =
+            getProp.getNext() != null
+                ? simpleInferExprType(getProp.getNext())
+                : getCommonTypes().UNKNOWN;
+        if (type != null) {
+          def.addProperty(recv.getNext().getString(), type);
         }
+      }
+      if (recvType == null) {
         return;
       }
       recvType = recvType.removeType(getCommonTypes().NULL_OR_UNDEFINED);

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

@@ -256,15 +256,13 @@ public TypedScope createScope(Node root, Scope parent) {
     scopeBuilder.resolveStubDeclarations();
 
     if (typedParent == null) {
-      try (NominalTypeBuilderOti.Factory factory = new NominalTypeBuilderOti.Factory()) {
-        List<NominalTypeBuilder> delegateProxies = new ArrayList<>();
-        for (FunctionType delegateProxyCtor : delegateProxyCtors) {
-          delegateProxies.add(
-              factory.builder(delegateProxyCtor, delegateProxyCtor.getInstanceType()));
-        }
-        codingConvention.defineDelegateProxyPrototypeProperties(
-            typeRegistry, delegateProxies, delegateCallingConventions);
+      List<NominalTypeBuilder> delegateProxies = new ArrayList<>();
+      for (FunctionType delegateProxyCtor : delegateProxyCtors) {
+        delegateProxies.add(
+            new NominalTypeBuilderOti(delegateProxyCtor, delegateProxyCtor.getInstanceType()));
       }
+      codingConvention.defineDelegateProxyPrototypeProperties(
+          typeRegistry, delegateProxies, delegateCallingConventions);
     }
 
     newScope.setTypeResolver(scopeBuilder);
@@ -1504,12 +1502,10 @@ private void checkForClassDefiningCalls(Node n) {
           FunctionType superCtor = superClass.getConstructor();
           FunctionType subCtor = subClass.getConstructor();
           if (superCtor != null && subCtor != null) {
-            try (NominalTypeBuilderOti.Factory factory = new NominalTypeBuilderOti.Factory()) {
-              codingConvention.applySubclassRelationship(
-                  factory.builder(superCtor, superClass),
-                  factory.builder(subCtor, subClass),
-                  relationship.type);
-            }
+            codingConvention.applySubclassRelationship(
+                new NominalTypeBuilderOti(superCtor, superClass),
+                new NominalTypeBuilderOti(subCtor, subClass),
+                relationship.type);
           }
         }
       }
@@ -1524,10 +1520,8 @@ private void checkForClassDefiningCalls(Node n) {
 
           if (functionType != null) {
             FunctionType getterType = typeRegistry.createFunctionType(objectType);
-            try (NominalTypeBuilderOti.Factory factory = new NominalTypeBuilderOti.Factory()) {
-              codingConvention.applySingletonGetter(
-                  factory.builder(functionType, objectType), getterType);
-            }
+            codingConvention.applySingletonGetter(
+                new NominalTypeBuilderOti(functionType, objectType), getterType);
           }
         }
       }
@@ -1595,15 +1589,13 @@ private void applyDelegateRelationship(
                   false /* isAbstract */);
           delegateProxy.setPrototypeBasedOn(delegateBaseObject);
 
-          try (NominalTypeBuilderOti.Factory factory = new NominalTypeBuilderOti.Factory()) {
-            codingConvention.applyDelegateRelationship(
-                factory.builder(delegateSuperCtor, delegateSuperObject),
-                factory.builder(delegateBaseCtor, delegateBaseObject),
-                factory.builder(delegatorCtor, delegatorObject),
-                (ObjectType) delegateProxy.getTypeOfThis(),
-                findDelegate);
-            delegateProxyCtors.add(delegateProxy);
-          }
+          codingConvention.applyDelegateRelationship(
+              new NominalTypeBuilderOti(delegateSuperCtor, delegateSuperObject),
+              new NominalTypeBuilderOti(delegateBaseCtor, delegateBaseObject),
+              new NominalTypeBuilderOti(delegatorCtor, delegatorObject),
+              (ObjectType) delegateProxy.getTypeOfThis(),
+              findDelegate);
+          delegateProxyCtors.add(delegateProxy);
         }
       }
     }

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

@@ -346,7 +346,6 @@ public Set<String> getAllNonInheritedInstanceProps() {
   }
 
   public NominalType getInstantiatedSuperclass() {
-    checkState(this.rawType.isFrozen());
     if (this.rawType.getSuperClass() == null) {
       return null;
     }