[NTI] Migrate AmbiguateProperties to TypeI

Extracts some common functionality between AmbiguateProperties and InlineProperties into InvalidatingTypes.

Of additional note is the removal of FunctionTypeI#getDirectImplementors.  This has been folded into the newly-implemented FunctionTypeI#getSubTypes, which now no longer ever returns null.

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

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

@@ -829,7 +829,7 @@ private boolean isInvalidatingType(TypeI type) {
       // 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()
+      return objType.isAmbiguousObject()
           // Invalidate constructors of already-invalidated types
           || (ft != null && ft.isConstructor() && isInvalidatingType(ft.getInstanceType()));
     }

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

@@ -50,7 +50,7 @@ boolean isInvalidating(TypeI type) {
     ObjectTypeI objType = type.toMaybeObjectType();
     return objType == null
         || types.contains(objType)
-        || objType.isUnknownObject()
+        || objType.isAmbiguousObject()
         || objType.isUnknownType()
         || objType.isBottom()
         || objType.isEnumObject()

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

@@ -1732,7 +1732,7 @@ public final boolean isUnknownType() {
   public final boolean isSomeUnknownType() {
     FunctionType ft = this.getFunTypeIfSingletonObj();
     return isUnknown()
-        || (isUnknownObject() && isLoose())
+        || (isAmbiguousObject() && isLoose())
         || (ft != null && ft.isTopFunction());
   }
 
@@ -2021,14 +2021,9 @@ public final boolean isPrototypeObject() {
   }
 
   @Override
-  public final boolean isUnknownObject() {
-    if (isSingletonObj()) {
-      ObjectType obj = getObjTypeIfSingletonObj();
-      NominalType nt = getNominalTypeIfSingletonObj();
-      return (nt.isBuiltinObject() || nt.isLiteralObject())
-          && !obj.isEnumObject() && !obj.isPrototypeObject();
-    }
-    return false;
+  public final boolean isAmbiguousObject() {
+    ObjectType obj = getObjTypeIfSingletonObj();
+    return obj != null && obj.isAmbiguousObject();
   }
 
   final boolean isBuiltinObjectPrototype() {

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

@@ -1563,14 +1563,36 @@ ObjectType substituteGenerics(Map<String, JSType> typeMap) {
 
   /**
    * Looks for the given property name (which must be a non-qualified
-   * identifier) on any nominal subtypes.  The built-in object type
+   * identifier) on any nominal subtypes. The built-in object type
    * always returns true.
    */
   boolean isPropDefinedOnSubtype(QualifiedName pname) {
     checkArgument(pname.isIdentifier());
     return this.nominalType.isBuiltinObject() || this.nominalType.isPropDefinedOnSubtype(pname);
   }
 
+  /**
+   * Returns true if this object refers to the type of an ambiguous object
+   */
+  boolean isAmbiguousObject() {
+    // TODO(sdh): It's somewhat odd that we treat function namespaces differently
+    // from object namespaces. The reason is for consistency with OTI, which treats
+    // most object literals as anonymous objects, but not so for functions. We
+    // could remove the 'fn' check and simply return true for all namespaces, but
+    // we'll need to update a bunch of expectations in DisambiguatePropertiesTest
+    // (which will then differ from OTI).
+    if (isEnumObject() || isPrototypeObject() || (this.ns != null && this.fn != null)) {
+      return false;
+    }
+    // All constructors have "Function" as their nominalType, so look at instance
+    // types instead for these cases.
+    NominalType nt =
+        (fn != null && fn.isSomeConstructorOrInterface())
+        ? fn.getInstanceTypeOfCtor().getObjTypeIfSingletonObj().nominalType
+        : this.nominalType;
+    return nt.isFunction() || nt.isBuiltinObject() || nt.isLiteralObject();
+  }
+
   @Override
   public String toString() {
     return appendTo(new StringBuilder(), ToStringContext.TO_STRING).toString();
@@ -1590,9 +1612,9 @@ StringBuilder appendTo(StringBuilder builder, ToStringContext ctx) {
       }
       return this.nominalType.appendTo(builder, ctx);
     }
-    if (!nominalType.getName().equals("Function")
-        && !nominalType.getName().equals("Object")
-        && !nominalType.getName().equals(JSTypes.OBJLIT_CLASS_NAME)) {
+    if (!nominalType.isFunction()
+        && !nominalType.isBuiltinObject()
+        && !nominalType.isLiteralObject()) {
       nominalType.appendTo(builder, ctx);
     } else if (isStruct()) {
       builder.append("struct");

src/com/google/javascript/rhino/ObjectTypeI.java

@@ -115,10 +115,11 @@ public interface ObjectTypeI extends TypeI {
   ObjectTypeI normalizeObjectForCheckAccessControls();
 
   /**
-   * Returns true if this object is an anonymous object type (i.e. the builtin Object type, or an
-   * object literal). Everything else has a named reference type and returns false.
+   * Returns true if this object is an anonymous object or function type (i.e. the builtin Object
+   * or Function type, or a record or function literal). These types are ambiguous and should not
+   * participate in property renaming. Everything else has a named reference type and returns false.
    */
-  boolean isUnknownObject();
+  boolean isAmbiguousObject();
 
   /**
    * The old type checker uses NamedType to wrap types (e.g., defined by typedefs), and to represent

src/com/google/javascript/rhino/jstype/ObjectType.java

@@ -252,7 +252,7 @@ public boolean hasReferenceName() {
   }
 
   @Override
-  public final boolean isUnknownObject() {
+  public final boolean isAmbiguousObject() {
     return !hasReferenceName();
   }