[NTI] When there is a type mismatch, show the part of the type causin…

…g the mismatch when possible.

/////////////////////////////////////////////
Sample new messages:

Invalid type for parameter 1 of function f.
Expected : {a:number, b:string}
Found    : {a:number, b:number}
More details:
Incompatible types for property b.
Expected : string
Found    : number

Invalid type for parameter 1 of function f.
Expected : Foo
Found    : Bar|null
More details:
The found type is a union that includes an unexpected type: null

Invalid type for parameter 1 of function f.
Expected : function(number|string):?
Found    : function(number):undefined
More details:
The expected and found types are functions which have incompatible types for argument 1.
Expected a supertype of : number|string
but found               : number
/////////////////////////////////////////////
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=122292354

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

@@ -31,6 +31,7 @@
 import com.google.javascript.jscomp.newtypes.FunctionTypeBuilder;
 import com.google.javascript.jscomp.newtypes.JSType;
 import com.google.javascript.jscomp.newtypes.JSTypes;
+import com.google.javascript.jscomp.newtypes.MismatchInfo;
 import com.google.javascript.jscomp.newtypes.QualifiedName;
 import com.google.javascript.jscomp.newtypes.TypeEnv;
 import com.google.javascript.jscomp.newtypes.UniqueNameGenerator;
@@ -69,33 +70,28 @@ final class NewTypeInference implements CompilerPass {
   static final DiagnosticType MISTYPED_ASSIGN_RHS = DiagnosticType.warning(
       "JSC_NTI_MISTYPED_ASSIGN_RHS",
       "The right side in the assignment is not a subtype of the left side.\n"
-      + "left side  : {0}\n"
-      + "right side : {1}\n");
+      + "{0}");
 
   static final DiagnosticType INVALID_OPERAND_TYPE = DiagnosticType.warning(
       "JSC_NTI_INVALID_OPERAND_TYPE",
       "Invalid type(s) for operator {0}.\n"
-      + "expected : {1}\n"
-      + "found    : {2}\n");
+      + "{1}");
 
   static final DiagnosticType RETURN_NONDECLARED_TYPE = DiagnosticType.warning(
       "JSC_NTI_RETURN_NONDECLARED_TYPE",
-      "Returned type does not match declared return type.\n" +
-      "declared : {0}\n" +
-      "found    : {1}\n");
+      "Returned type does not match declared return type.\n"
+      + "{0}");
 
   static final DiagnosticType INVALID_INFERRED_RETURN_TYPE =
       DiagnosticType.warning(
           "JSC_NTI_INVALID_INFERRED_RETURN_TYPE",
-          "Function called in context that expects incompatible type.\n" +
-          "expected : {0}\n" +
-          "found    : {1}\n");
+          "Function called in context that expects incompatible type.\n"
+          + "{0}");
 
   static final DiagnosticType INVALID_ARGUMENT_TYPE = DiagnosticType.warning(
       "JSC_NTI_INVALID_ARGUMENT_TYPE",
-      "Invalid type for parameter {0} of function {1}.\n" +
-      "expected : {2}\n" +
-      "found    : {3}\n");
+      "Invalid type for parameter {0} of function {1}.\n"
+      + "{2}");
 
   static final DiagnosticType CROSS_SCOPE_GOTCHA = DiagnosticType.warning(
       "JSC_NTI_CROSS_SCOPE_GOTCHA",
@@ -130,8 +126,7 @@ final class NewTypeInference implements CompilerPass {
       DiagnosticType.warning(
           "JSC_NTI_INVALID_INDEX_TYPE",
           "Invalid type for index.\n"
-          + "expected : {0}\n"
-          + "found    : {1}\n");
+          + "{0}");
 
   static final DiagnosticType BOTTOM_INDEX_TYPE =
       DiagnosticType.warning(
@@ -142,7 +137,8 @@ final class NewTypeInference implements CompilerPass {
   static final DiagnosticType INVALID_OBJLIT_PROPERTY_TYPE =
       DiagnosticType.warning(
           "JSC_NTI_INVALID_OBJLIT_PROPERTY_TYPE",
-          "Object-literal property declared as {0} but has type {1}.");
+          "Invalid type for object-literal property.\n"
+          + "{0}");
 
   static final DiagnosticType FORIN_EXPECTS_OBJECT =
       DiagnosticType.warning(
@@ -182,8 +178,8 @@ final class NewTypeInference implements CompilerPass {
   static final DiagnosticType INVALID_THIS_TYPE_IN_BIND =
       DiagnosticType.warning(
           "JSC_NTI_INVALID_THIS_TYPE_IN_BIND",
-          "The first argument to bind has type {0} which is not a subtype of"
-          + " {1}.");
+          "Invalid type for the first argument to bind.\n"
+          + "{0}");
 
   static final DiagnosticType CANNOT_BIND_CTOR =
       DiagnosticType.warning(
@@ -245,7 +241,7 @@ final class NewTypeInference implements CompilerPass {
   static final DiagnosticType NOT_CALLABLE =
       DiagnosticType.warning(
           "JSC_NTI_NOT_FUNCTION_TYPE",
-          "{0} expressions are not callable");
+          "Cannot call non-function type {0}");
 
   static final DiagnosticType WRONG_ARGUMENT_COUNT =
       DiagnosticType.warning(
@@ -854,7 +850,7 @@ private void analyzeFunctionFwd(
           }
           if (!actualRetType.isSubtypeOf(declRetType)) {
             warnings.add(JSError.make(n, RETURN_NONDECLARED_TYPE,
-                    declRetType.toString(), actualRetType.toString()));
+                    errorMsgWithTypeDiff(declRetType, actualRetType)));
           }
           break;
         }
@@ -1154,7 +1150,7 @@ private TypeEnv processVarDeclaration(Node nameNode, TypeEnv inEnv) {
       if (!rhsType.isSubtypeOf(declType)) {
         warnings.add(JSError.make(
             rhs, MISTYPED_ASSIGN_RHS,
-            declType.toString(), rhsType.toString()));
+            errorMsgWithTypeDiff(declType, rhsType)));
         // Don't flow the wrong initialization
         rhsType = declType;
       } else {
@@ -1926,7 +1922,7 @@ private EnvTypePair analyzeFunctionBindFwd(Node call, TypeEnv inEnv) {
       env = pair.env;
       if (!pair.type.isSubtypeOf(reqThisType)) {
         warnings.add(JSError.make(call, INVALID_THIS_TYPE_IN_BIND,
-                pair.type.toString(), reqThisType.toString()));
+                errorMsgWithTypeDiff(reqThisType, pair.type)));
       }
     }
 
@@ -1967,7 +1963,7 @@ private TypeEnv analyzeCallNodeArgumentsFwd(Node call, Node firstArg,
         String fnName = getReadableCalleeName(call.getFirstChild());
         warnings.add(JSError.make(arg, INVALID_ARGUMENT_TYPE,
                 Integer.toString(i + 1), fnName,
-                formalType.toString(), pair.type.toString()));
+                errorMsgWithTypeDiff(formalType, pair.type)));
         argTypeForDeferredCheck = null; // No deferred check needed.
       }
       argTypesForDeferredCheck.add(argTypeForDeferredCheck);
@@ -2452,7 +2448,7 @@ private EnvTypePair analyzeObjLitFwd(
           if (!pair.type.isSubtypeOf(jsdocType)) {
             warnings.add(JSError.make(
                 prop, INVALID_OBJLIT_PROPERTY_TYPE,
-                jsdocType.toString(), pair.type.toString()));
+                errorMsgWithTypeDiff(jsdocType, pair.type)));
             pair.type = jsdocType;
           }
         }
@@ -2608,6 +2604,51 @@ private boolean tightenTypeAndDontWarn(
         && required.isNonLooseSubtypeOf(inferred);
   }
 
+  private static String errorMsgWithTypeDiff(JSType expected, JSType found) {
+    MismatchInfo mismatch = JSType.whyNotSubtypeOf(found, expected);
+    if (mismatch == null) {
+      return "Expected : " + expected + "\n"
+          + "Found    : " + found + "\n";
+    }
+    StringBuilder builder = new StringBuilder(
+        "Expected : " + expected + "\n"
+        + "Found    : " + found + "\n"
+        + "More details:\n");
+    if (mismatch.isPropMismatch()) {
+      builder.append(
+          "Incompatible types for property "
+          + mismatch.getPropName() + ".\n"
+          + "Expected : " + mismatch.getExpectedType() + "\n"
+          + "Found    : " + mismatch.getFoundType());
+    } else if (mismatch.isMissingProp()) {
+      builder.append(
+          "The found type is missing property "
+          + mismatch.getPropName());
+    } else if (mismatch.wantedRequiredFoundOptional()) {
+      builder.append(
+          "In found type, property " + mismatch.getPropName()
+          + " is optional but should be required.");
+    } else if (mismatch.isArgTypeMismatch()) {
+      builder.append(
+          "The expected and found types are functions which have"
+          + " incompatible types for argument "
+          + (mismatch.getArgIndex() + 1) + ".\n"
+          + "Expected a supertype of : " + mismatch.getExpectedType() + "\n"
+          + "but found               : " + mismatch.getFoundType());
+    } else if (mismatch.isRetTypeMismatch()) {
+      builder.append(
+          "The expected and found types are functions which have"
+          + " incompatible return types.\n"
+          + "Expected a subtype of : " + mismatch.getExpectedType() + "\n"
+          + "but found             : " + mismatch.getFoundType());
+    } else if (mismatch.isUnionTypeMismatch()) {
+      builder.append(
+          "The found type is a union that includes an unexpected type: "
+          + mismatch.getFoundType());
+    }
+    return builder.toString();
+  }
+
   //////////////////////////////////////////////////////////////////////////////
   // These functions return true iff they produce a warning
 
@@ -2764,7 +2805,7 @@ private boolean mayWarnAboutBadIObjectIndex(Node n, JSType iobjectType,
     if (!foundIndexType.isSubtypeOf(requiredIndexType)) {
       warnings.add(JSError.make(
           n, NewTypeInference.INVALID_INDEX_TYPE,
-          requiredIndexType.toString(), foundIndexType.toString()));
+          errorMsgWithTypeDiff(requiredIndexType, foundIndexType)));
       return true;
     }
     return false;
@@ -3547,9 +3588,16 @@ private void warnInvalidOperand(
         (expected instanceof String) || (expected instanceof JSType));
     Preconditions.checkArgument(
         (actual instanceof String) || (actual instanceof JSType));
-    warnings.add(JSError.make(
-        expr, INVALID_OPERAND_TYPE, Token.name(operatorType),
-        expected.toString(), actual.toString()));
+    if (expected instanceof JSType && actual instanceof JSType) {
+      warnings.add(JSError.make(
+          expr, INVALID_OPERAND_TYPE, Token.name(operatorType),
+          errorMsgWithTypeDiff((JSType) expected, (JSType) actual)));
+    } else {
+      warnings.add(JSError.make(
+          expr, INVALID_OPERAND_TYPE, Token.name(operatorType),
+          "Expected : " + expected.toString() + "\n"
+          + "Found    : " + actual.toString() + "\n"));
+    }
   }
 
   private static class EnvTypePair {
@@ -4029,8 +4077,8 @@ private void runCheck(
           !fnSummary.getReturnType().isSubtypeOf(this.expectedRetType)) {
         warnings.add(JSError.make(
             this.callSite, INVALID_INFERRED_RETURN_TYPE,
-            this.expectedRetType.toString(),
-            fnSummary.getReturnType().toString()));
+            errorMsgWithTypeDiff(
+                this.expectedRetType, fnSummary.getReturnType())));
       }
       int i = 0;
       Node argNode = callSite.getSecondChild();

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

@@ -415,11 +415,17 @@ private static FunctionType looseJoin(FunctionType f1, FunctionType f2) {
   }
 
   public boolean isValidOverride(FunctionType other) {
-    return isSubtypeOfHelper(other, false, SubtypeCache.create());
+    return isSubtypeOfHelper(other, false, SubtypeCache.create(), null);
   }
 
   boolean isSubtypeOf(FunctionType other, SubtypeCache subSuperMap) {
-    return isSubtypeOfHelper(other, true, subSuperMap);
+    return isSubtypeOfHelper(other, true, subSuperMap, null);
+  }
+
+  static void whyNotSubtypeOf(FunctionType f1, FunctionType f2,
+      SubtypeCache subSuperMap, MismatchInfo[] boxedInfo) {
+    Preconditions.checkArgument(boxedInfo.length == 1);
+    f1.isSubtypeOfHelper(f2, true, subSuperMap, boxedInfo);
   }
 
   // When we write ...?, it has a special meaning, it is NOT a variable-arity
@@ -431,8 +437,8 @@ private boolean acceptsAnyArguments() {
         && this.restFormals != null && this.restFormals.isUnknown();
   }
 
-  private boolean isSubtypeOfHelper(
-      FunctionType other, boolean checkThisType, SubtypeCache subSuperMap) {
+  private boolean isSubtypeOfHelper(FunctionType other, boolean checkThisType,
+      SubtypeCache subSuperMap, MismatchInfo[] boxedInfo) {
     if (other.isTopFunction() ||
         other.isQmarkFunction() || this.isQmarkFunction()) {
       return true;
@@ -452,7 +458,7 @@ private boolean isSubtypeOfHelper(
       // and the fix is not trivial, so for now we decided to not fix.
       // See unit tests in NewTypeInferenceES5OrLowerTest#testGenericsSubtyping
       return instantiateGenericsWithUnknown(this)
-          .isSubtypeOfHelper(other, checkThisType, subSuperMap);
+          .isSubtypeOfHelper(other, checkThisType, subSuperMap, boxedInfo);
     }
 
     if (!other.acceptsAnyArguments()) {
@@ -469,6 +475,10 @@ private boolean isSubtypeOfHelper(
         if (thisFormal != null
             && !thisFormal.isUnknown() && !otherFormal.isUnknown()
             && !otherFormal.isSubtypeOf(thisFormal, subSuperMap)) {
+          if (boxedInfo != null) {
+            boxedInfo[0] =
+                MismatchInfo.makeArgTypeMismatch(i, otherFormal, thisFormal);
+          }
           return false;
         }
       }
@@ -514,8 +524,14 @@ private boolean isSubtypeOfHelper(
     }
 
     // covariance in the return type
-    return returnType.isUnknown() || other.returnType.isUnknown()
-        || returnType.isSubtypeOf(other.returnType, subSuperMap);
+    boolean areRetTypesSubtypes = this.returnType.isUnknown()
+        || other.returnType.isUnknown()
+        || this.returnType.isSubtypeOf(other.returnType, subSuperMap);
+    if (boxedInfo != null) {
+      boxedInfo[0] =
+          MismatchInfo.makeRetTypeMismatch(other.returnType, this.returnType);
+    }
+    return areRetTypesSubtypes;
   }
 
   // Avoid using JSType#join if possible, to avoid creating new types