[NTI] Handle most of property disambiguation using NTI types.

Summary of changes:
- Mark types in externs in GlobalTypeInfo.
- Record mismatches and implicit uses in NTI.
- Change disambiguation unit tests for the cases where OTI and NTI differ.
- Implement some TypeI functions in NTI.
- Support inferred prototype properties in NTI.
- Annotate @Lends and prototype object literals in NTI.
- Move more code from TypeValidator to TypeMismatch.
- Add method instantiateGenericsWithUnknown to OTI.

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

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

@@ -1045,7 +1045,8 @@ private static ObjectTypeI dereference(TypeI type) {
    */
   private static ObjectTypeI getSuperClassInstanceIfFinal(TypeI type) {
     if (type != null) {
-      FunctionTypeI ctor = castToObject(type).getSuperClassConstructor();
+      ObjectTypeI obj = castToObject(type);
+      FunctionTypeI ctor = obj == null ? null : obj.getSuperClassConstructor();
       JSDocInfo doc = ctor == null ? null : ctor.getJSDocInfo();
       if (doc != null && doc.isFinal()) {
         return ctor.getInstanceType();

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

@@ -1445,7 +1445,14 @@ Iterable<TypeMismatch> getTypeMismatches() {
 
   @Override
   Iterable<TypeMismatch> getImplicitInterfaceUses() {
-    return getTypeValidator().getImplicitInterfaceUses();
+    switch (this.mostRecentTypechecker) {
+      case OTI:
+        return getTypeValidator().getImplicitInterfaceUses();
+      case NTI:
+        return getSymbolTable().getImplicitInterfaceUses();
+      default:
+        throw new RuntimeException("Can't ask for type mismatches before type checking.");
+    }
   }
 
   @Override

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

@@ -522,16 +522,14 @@ private void handleObjectLit(NodeTraversal t, Node n) {
 
         // We should never see a mix of numbers and strings.
         String name = child.getString();
-        TypeI type = getType(n);
-
+        TypeI objlitType = getType(n);
         Property prop = getProperty(name);
-        if (!prop.scheduleRenaming(child,
-                                   processProperty(t, prop, type, null))) {
+        if (!prop.scheduleRenaming(child, processProperty(t, prop, objlitType, null))) {
           // TODO(user): It doesn't look like the user can do much in this
           // case right now.
           if (propertiesToErrorFor.containsKey(name)) {
             compiler.report(JSError.make(child, propertiesToErrorFor.get(name),
-                Warnings.INVALIDATION, name, String.valueOf(type), n.toString(), ""));
+                Warnings.INVALIDATION, name, String.valueOf(objlitType), n.toString(), ""));
           }
         }
       }
@@ -825,7 +823,19 @@ private boolean isInvalidatingType(TypeI type) {
       return true;
     }
     ObjectTypeI objType = type.toMaybeObjectType();
-    return objType != null && objType.isUnknownObject();
+    if (objType != null) {
+      FunctionTypeI ft = objType.toMaybeFunctionType();
+      // TODO(dimvar): types of most object literals are considered anonymous objects, and as such,
+      // a property of an object literal prevents all properties with the same name from being
+      // disambiguated. In OTI, this might be hard to change, but in NTI, it is easy to change
+      // isUnknownObject to return false for object literals. I deliberately followed the behavior
+      // of OTI to help with the migration, but can revisit in the future to improve
+      // disambiguation.
+      return objType.isUnknownObject()
+          // Invalidate constructors of already-invalidated types
+          || (ft != null && ft.isConstructor() && isInvalidatingType(ft.getInstanceType()));
+    }
+    return false;
   }
 
   /**
@@ -940,7 +950,7 @@ private ObjectTypeI getTypeWithProperty(String field, TypeI type) {
         && objType.getConstructor().isInterface()) {
       ObjectTypeI topInterface = objType.getTopDefiningInterface(field);
       if (topInterface != null && topInterface.getConstructor() != null) {
-        foundType = topInterface.getConstructor().getPrototypeProperty();
+        foundType = topInterface.getPrototypeObject();
       }
     } else {
       while (objType != null && !Objects.equals(objType.getPrototypeObject(), objType)) {

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

@@ -283,6 +283,7 @@ class GlobalTypeInfo implements CompilerPass, TypeIRegistry {
   private NTIScope globalScope;
   private WarningReporter warnings;
   private final List<TypeMismatch> mismatches;
+  private final List<TypeMismatch> implicitInterfaceUses;
   private final JSTypeCreatorFromJSDoc typeParser;
   private final AbstractCompiler compiler;
   private final CodingConvention convention;
@@ -327,6 +328,7 @@ class GlobalTypeInfo implements CompilerPass, TypeIRegistry {
 
     this.warnings = new WarningReporter(compiler);
     this.mismatches = new ArrayList<>();
+    this.implicitInterfaceUses = new ArrayList<>();
     this.compiler = compiler;
     this.unknownTypeNames = unknownTypeNames;
     this.convention = compiler.getCodingConvention();
@@ -362,6 +364,10 @@ List<TypeMismatch> getMismatches() {
     return this.mismatches;
   }
 
+  List<TypeMismatch> getImplicitInterfaceUses() {
+    return this.implicitInterfaceUses;
+  }
+
   JSType getCastType(Node n) {
     JSType t = castTypes.get(n);
     Preconditions.checkNotNull(t);
@@ -504,6 +510,21 @@ public void process(Node externs, Node root) {
     for (NTIScope s : scopes) {
       s.finalizeScope();
     }
+
+    // Traverse the externs and annotate them with types.
+    // Only works for the top level, not inside function bodies.
+    NodeTraversal.traverseEs6(
+        this.compiler, externs, new NodeTraversal.AbstractShallowCallback(){
+          @Override
+          public void visit(NodeTraversal t, Node n, Node parent) {
+            if (n.isQualifiedName()) {
+              Declaration d = globalScope.getDeclaration(QualifiedName.fromNode(n), false);
+              JSType type = simpleInferDeclaration(d);
+              n.setTypeI(type);
+            }
+          }
+        });
+
     Map<Node, String> unknownTypes = typeParser.getUnknownTypesMap();
     for (Map.Entry<Node, String> unknownTypeEntry : unknownTypes.entrySet()) {
       this.warnings.add(JSError.make(unknownTypeEntry.getKey(),
@@ -526,6 +547,38 @@ public void process(Node externs, Node root) {
     this.compiler.setExternProperties(ImmutableSet.copyOf(this.externPropertyNames));
   }
 
+  private JSType simpleInferDeclaration(Declaration decl) {
+    if (decl == null) {
+      return null;
+    }
+    // Namespaces (literals, enums, constructors) get populated during ProcessScope,
+    // so it's generally NOT safe to convert them to jstypes until after ProcessScope is done.
+    // However, we've seen examples where it is useful to use the constructor type
+    // during inference, e.g., to get the type of the instance from it.
+    // We allow this use case but add a marker property to make sure that the constructor type
+    // itself doesn't leak into the result.
+    if (decl.getNominal() != null) {
+      FunctionType ctorFn = decl.getNominal().getConstructorFunction();
+      if (ctorFn == null) {
+        return null;
+      }
+      return commonTypes.fromFunctionType(ctorFn)
+          .withProperty(CONST_INFERENCE_MARKER, commonTypes.UNKNOWN);
+    }
+    if (decl.getTypeOfSimpleDecl() != null) {
+      return decl.getTypeOfSimpleDecl();
+    }
+    NTIScope funScope = (NTIScope) decl.getFunctionScope();
+    if (funScope != null) {
+      DeclaredFunctionType dft = funScope.getDeclaredFunctionType();
+      if (dft == null) {
+        return null;
+      }
+      return commonTypes.fromFunctionType(dft.toFunctionType());
+    }
+    return null;
+  }
+
   private Collection<PropertyDef> getPropDefsFromInterface(NominalType nominalType, String pname) {
     Preconditions.checkArgument(nominalType.isFinalized());
     Preconditions.checkArgument(nominalType.isInterface() || nominalType.isBuiltinObject());
@@ -819,8 +872,7 @@ public void visit(NodeTraversal t, Node n, Node parent) {
             visitEnum(nameNode);
           } else if (isAliasedNamespaceDefinition(nameNode)) {
             visitAliasedNamespace(nameNode);
-          } else if (varName.equals(WINDOW_INSTANCE)
-              && nameNode.isFromExterns()) {
+          } else if (varName.equals(WINDOW_INSTANCE) && nameNode.isFromExterns()) {
             visitWindowVar(nameNode);
           } else if (isCtorDefinedByCall(nameNode)) {
             visitNewCtorDefinedByCall(nameNode);
@@ -1220,7 +1272,11 @@ private void maybeRecordNominalType(
             || mayCreateFunctionNamespace(firstChild)
             || mayCreateWindowNamespace(firstChild)) {
           if (nameNode.isGetProp()) {
-            defSite.getParent().getFirstChild().putBooleanProp(Node.ANALYZED_DURING_GTI, true);
+            if (defSite.isFunction()) {
+              defSite.getParent().putBooleanProp(Node.ANALYZED_DURING_GTI, true);
+            } else {
+              defSite.getParent().getFirstChild().putBooleanProp(Node.ANALYZED_DURING_GTI, true);
+            }
           } else if (currentScope.isTopLevel()) {
             maybeRecordBuiltinType(qname, rawType);
           }
@@ -1234,8 +1290,7 @@ private void maybeRecordNominalType(
       }
     }
 
-    private void maybeRecordBuiltinType(
-        String name, RawNominalType rawType) {
+    private void maybeRecordBuiltinType(String name, RawNominalType rawType) {
       switch (name) {
         case "Arguments":
           commonTypes.setArgumentsType(rawType);
@@ -1358,8 +1413,8 @@ void processLendsNode(Node objlit) {
       if (currentScope.isNamespace(lendsQname)) {
         processLendsToNamespace(lendsQname, lendsName, objlit);
       } else {
-        RawNominalType rawType = checkValidLendsToPrototypeAndGetClass(
-            lendsQname, lendsName, objlit);
+        RawNominalType rawType =
+            checkValidLendsToPrototypeAndGetClass(lendsQname, lendsName, objlit);
         if (rawType != null) {
           for (Node prop : objlit.children()) {
             String pname =  NodeUtil.getObjectLitKeyName(prop);
@@ -2263,38 +2318,6 @@ private JSType simpleInferGetelemType(Node n) {
       return null;
     }
 
-    private JSType simpleInferDeclaration(Declaration decl) {
-      if (decl == null) {
-        return null;
-      }
-      // Namespaces (literals, enums, constructors) get populated during ProcessScope,
-      // so it's generally NOT safe to convert them to jstypes until after ProcessScope is done.
-      // However, we've seen examples where it is useful to use the constructor type
-      // during inference, e.g., to get the type of the instance from it.
-      // We allow this use case but add a marker property to make sure that the constructor type
-      // itself doesn't leak into the result.
-      if (decl.getNominal() != null) {
-        FunctionType ctorFn = decl.getNominal().getConstructorFunction();
-        if (ctorFn == null) {
-          return null;
-        }
-        return commonTypes.fromFunctionType(ctorFn)
-            .withProperty(CONST_INFERENCE_MARKER, commonTypes.UNKNOWN);
-      }
-      if (decl.getTypeOfSimpleDecl() != null) {
-        return decl.getTypeOfSimpleDecl();
-      }
-      NTIScope funScope = (NTIScope) decl.getFunctionScope();
-      if (funScope != null) {
-        DeclaredFunctionType dft = funScope.getDeclaredFunctionType();
-        if (dft == null) {
-          return null;
-        }
-        return commonTypes.fromFunctionType(dft.toFunctionType());
-      }
-      return null;
-    }
-
     private JSType simpleInferAndOrType(Node n) {
       Preconditions.checkState(n.isOr() || n.isAnd());
       JSType lhs = simpleInferExprTypeRecur(n.getFirstChild());
@@ -2591,7 +2614,14 @@ private void mayAddPropToPrototype(
           }
         }
       } else {
-        rawType.addUndeclaredProtoProperty(pname, defSite);
+        JSType inferredType = null;
+        if (initializer != null) {
+          inferredType = simpleInferExprType(initializer);
+        }
+        if (inferredType == null) {
+          inferredType = commonTypes.UNKNOWN;
+        }
+        rawType.addUndeclaredProtoProperty(pname, defSite, inferredType);
       }
     }
 

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

@@ -425,8 +425,7 @@ Set<String> getExterns() {
   // If a variable is declared many times in a scope, the last definition
   // overwrites the previous ones. For correctness, we rely on the fact that
   // the var-check passes run before type checking.
-  void addLocal(String name, JSType declType,
-      boolean isConstant, boolean isFromExterns) {
+  void addLocal(String name, JSType declType, boolean isConstant, boolean isFromExterns) {
     Preconditions.checkArgument(!name.contains("."));
     if (isConstant) {
       constVars.add(name);
@@ -658,8 +657,7 @@ void resolveEnums(JSTypeCreatorFromJSDoc typeParser) {
   }
 
   void finalizeScope() {
-    Preconditions.checkNotNull(
-        this.declaredType, "No declared type for scope: %s", this.root);
+    Preconditions.checkNotNull(this.declaredType, "No declared type for scope: %s", this.root);
     unknownTypeNames = ImmutableSet.of();
     // For now, we put types of namespaces directly into the locals.
     // Alternatively, we could move this into NewTypeInference.initEdgeEnvs