Move CallExpr diagnostics over to the same overload candidate diagnosis

facilities used by operators etc.  This required a bunch of changes to make
the diagnostics changes strictly an improvement:

  - Teach the new path about calls to TypeExprs.
  - Teach evaluateCloseness some simple things about varargs.
  - Make the generic diagnosis logic produce a better error when there is 
    exactly one match.

Overall, the resultant diagnostics are a step forward: we now produce candidate
set notes more uniformly, and the messages about some existing ones are 
more specific.  This is just another stepping stone towards progress though.



Swift SVN r30057

Author: lattner

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -141,9 +141,6 @@ ERROR(cannot_apply_initializer_to_args,sema,none,
       "cannot invoke initializer for type '%0' with an argument list of type "
       "'%1'", (StringRef,StringRef))
 
-NOTE(expected_certain_args,sema_nb,none,
-      "expected an argument list of type '%0'", (StringRef))
-
 ERROR(cannot_find_appropriate_overload_with_list,sema,none,
       "cannot find an overload for '%0' that accepts an argument list of"
       " type '%1'", (StringRef, StringRef))
@@ -170,6 +167,9 @@ NOTE(mult_stmt_closures_require_explicit_result,sema,none,
 ERROR(invalid_trailing_closure_target,sema,none,
       "unexpected trailing closure", ())
 
+NOTE(suggest_expected_match,sema,none,
+     "expected an argument list of type '%0'", (StringRef))
+
 NOTE(suggest_partial_overloads,sema,none,
       "overloads for '%0' exist with these partially matching parameter "
       "lists: %1", (StringRef, StringRef))

Diff for: lib/Sema/CSDiag.cpp

@@ -1716,12 +1716,10 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
 
   /// Given a set of parameter lists from an overload group, and a list of
   /// arguments, emit a diagnostic indicating any partially matching overloads.
-  void suggestPotentialOverloads(StringRef functionName, SourceLoc loc,
-                                 const SmallVectorImpl<Type> &paramLists,
-                                 Type argType);
   void suggestPotentialOverloads(StringRef functionName, SourceLoc loc,
                                  ArrayRef<ValueDecl*> candidates,
-                                 CandidateCloseness closeness);
+                                 CandidateCloseness closeness,
+                                 bool isCallExpr = false);
 
   bool visitExpr(Expr *E);
 
@@ -2101,6 +2099,7 @@ Expr *FailureDiagnosis::typeCheckIndependentSubExpression(Expr *subExpr) {
   if (!isa<ClosureExpr>(subExpr) &&
       (isa<ApplyExpr>(subExpr) || isa<ArrayExpr>(subExpr) ||
        isa<ForceValueExpr>(subExpr) ||
+       //isa<UnresolvedDotExpr>(subExpr) ||
        typeIsNotSpecialized(subExpr->getType()))) {
 
     // Store off the sub-expression, in case a new one is provided via the
@@ -2179,68 +2178,27 @@ bool FailureDiagnosis::diagnoseContextualConversionError(Type exprResultType) {
   return true;
 }
 
-// FIXME: Remove this!
-void FailureDiagnosis::suggestPotentialOverloads(StringRef functionName,
-                                                 SourceLoc loc,
-                               const SmallVectorImpl<Type> &paramLists,
-                                                 Type argType) {
-  // FIXME: This is arbitrary.
-  if (argType->isVoid())
-    return;
-
-  auto argTypeElts = decomposeArgumentType(argType);
-
-  std::string suggestionText = "";
-  std::map<std::string, bool> dupes;
-
-  for (auto paramList : paramLists) {
-    auto paramTypeElts = decomposeArgumentType(paramList);
-
-    if (paramTypeElts.size() != argTypeElts.size())
-      continue;
-  /// FIXME: Right now, a "matching" overload is one with a parameter whose type
-  /// is identical to one of the argument types. We can obviously do something
-  /// more sophisticated with this.
-    for (size_t i = 0, e = paramTypeElts.size(); i != e; i++) {
-      auto pt = paramTypeElts[i];
-      auto at = argTypeElts[i];
-      if (pt->isEqual(at->getRValueType())) {
-        auto typeListString = getTypeListString(paramList);
-        if (!dupes[typeListString]) {
-          dupes[typeListString] = true;
-          if (!suggestionText.empty())
-            suggestionText += ", ";
-          suggestionText += typeListString;
-        }
-        break;
-      }
-    }
-  }
-  
-  if (suggestionText.empty())
-    return;
-  
-  CS->TC.diagnose(loc, diag::suggest_partial_overloads,
-                  functionName, suggestionText);
-}
-
 void FailureDiagnosis::
 suggestPotentialOverloads(StringRef functionName, SourceLoc loc,
                           ArrayRef<ValueDecl*> candidates,
-                          CandidateCloseness closeness) {
+                          CandidateCloseness closeness,
+                          bool isCallExpr) {
 
   // If the candidate list is has no near matches to the actual types, don't
   // print out a candidate list, it will just be noise.
-  if (closeness == CC_ArgumentCountMismatch ||
-      closeness == CC_GeneralMismatch)
-    return;
+  if ((closeness == CC_ArgumentCountMismatch ||
+       closeness == CC_GeneralMismatch)) {
+    
+    // FIXME: This is arbitrary.
+    if (candidates.size() != 1 || !isCallExpr)
+      return;
+  }
 
   std::string suggestionText = "";
   std::set<std::string> dupes;
 
   // FIXME2: For (T,T) & (Self, Self), emit this as two candidates, one using
   // the LHS and one using the RHS type for T's.
-  
   for (auto decl : candidates) {
     Type paramListType;
 
@@ -2269,8 +2227,13 @@ suggestPotentialOverloads(StringRef functionName, SourceLoc loc,
   if (suggestionText.empty())
     return;
 
-  CS->TC.diagnose(loc, diag::suggest_partial_overloads,
-                  functionName, suggestionText);
+  if (dupes.size() == 1) {
+    CS->TC.diagnose(loc, diag::suggest_expected_match,
+                    suggestionText);
+  } else {
+    CS->TC.diagnose(loc, diag::suggest_partial_overloads,
+                    functionName, suggestionText);
+  }
 }
 
 
@@ -2309,9 +2272,23 @@ static FailureDiagnosis::CandidateCloseness
 evaluateCloseness(Type candArgListType, ArrayRef<Type> actualArgs) {
   auto candArgs = decomposeArgumentType(candArgListType);
 
-  // FIXME: This isn't handling varargs.
-  if (actualArgs.size() != candArgs.size())
+  // FIXME: This isn't handling varargs, and isn't handling default values
+  // either.
+  if (actualArgs.size() != candArgs.size()) {
+    // If the candidate is varargs, and if there are more arguments specified
+    // than required, consider this a general mismatch.
+    // TODO: we could catalog the remaining entries if they *do* match up.
+    if (auto *TT = candArgListType->getAs<TupleType>()) {
+      if (!TT->getElements().empty()) {
+        if (TT->getElements().back().isVararg() &&
+            actualArgs.size() >= TT->getElements().size()-1)
+          return FailureDiagnosis::CC_GeneralMismatch;
+      }
+    }
+    
+    
     return FailureDiagnosis::CC_ArgumentCountMismatch;
+  }
 
   // Count the number of mismatched arguments.
   unsigned mismatchingArgs = 0;
@@ -2336,6 +2313,8 @@ evaluateCloseness(Type candArgListType, ArrayRef<Type> actualArgs) {
   if (mismatchingArgs == 1)
     return FailureDiagnosis::CC_OneArgumentMismatch;
 
+  // TODO: Keyword argument mismatches.
+  
   return FailureDiagnosis::CC_GeneralMismatch;
 }
 
@@ -2351,6 +2330,16 @@ FailureDiagnosis::collectCalleeCandidateInfo(Expr *fn, Type actualArgsType,
   } else if (auto overloadedDRE = dyn_cast<OverloadedDeclRefExpr>(fn)) {
     result.append(overloadedDRE->getDecls().begin(),
                   overloadedDRE->getDecls().end());
+  } else if (auto TE = dyn_cast<TypeExpr>(fn)) {
+    // It's always a metatype type, so use the instance type name.
+    auto instanceType = TE->getType()->getAs<MetatypeType>()->getInstanceType();
+    
+    // TODO: figure out right value for isKnownPrivate
+    if (!instanceType->getAs<TupleType>()) {
+      auto ctors = CS->TC.lookupConstructors(CS->DC, instanceType);
+      for (auto ctor : ctors)
+        result.push_back(ctor);
+    }
   } else if (overloadConstraint) {
     result.push_back(overloadConstraint->getOverloadChoice().getDecl());
   } else {
@@ -2654,65 +2643,42 @@ bool FailureDiagnosis::visitSubscriptExpr(SubscriptExpr *SE) {
 bool FailureDiagnosis::visitCallExpr(CallExpr *callExpr) {
   CleanupIllFormedExpressionRAII cleanup(CS->getASTContext(), expr);
 
+  // FIXME: Should be calculating types of sub-exprs in a consistent way.
+  //auto fnExpr = typeCheckIndependentSubExpression(callExpr->getFn());
+  //if (!fnExpr) return true;
   auto fnExpr = callExpr->getFn();
   auto argExpr = callExpr->getArg();
 
   // An error was posted elsewhere.
   if (isErrorTypeKind(fnExpr->getType()))
     return true;
 
-
   std::string overloadName = "";
 
   bool isClosureInvocation = false;
   bool isInvalidTrailingClosureTarget = false;
   bool isInitializer = false;
   bool isOverloadedFn = false;
-  
-  llvm::SmallVector<Type, 16> paramLists;
 
+  CandidateCloseness candidateCloseness;
+  auto Candidates = collectCalleeCandidateInfo(fnExpr, argExpr->getType(),
+                                               candidateCloseness);
+
+  
   // Obtain the function's name, and collect any parameter lists for diffing
   // purposes.
   if (auto DRE = dyn_cast<DeclRefExpr>(fnExpr)) {
     overloadName = DRE->getDecl()->getNameStr();
-    
-    if (auto fnType = DRE->getDecl()->getType()->getAs<AnyFunctionType>()) {
-      paramLists.push_back(fnType->getInput());
-    }
-    
   } else if (auto ODRE = dyn_cast<OverloadedDeclRefExpr>(fnExpr)) {
     isOverloadedFn = true;
     overloadName = ODRE->getDecls()[0]->getNameStr().str();
-    
-    // Collect the parameters for later use.
-    for (auto D : ODRE->getDecls()) {
-      if (auto fnType = D->getType()->getAs<AnyFunctionType>()) {
-        paramLists.push_back(fnType->getInput());
-      }
-    }
-    
-  } else if (auto TE = dyn_cast<TypeExpr>(fnExpr)) {
+  } else if (isa<TypeExpr>(fnExpr)) {
     isInitializer = true;
-    
+    isOverloadedFn = Candidates.size() > 1;
     // It's always a metatype type, so use the instance type name.
-    auto instanceType = TE->getType()->getAs<MetatypeType>()->getInstanceType();
+    auto instanceType =
+      fnExpr->getType()->castTo<MetatypeType>()->getInstanceType();
     overloadName = instanceType->getString();
-
-    // TODO: figure out right value for isKnownPrivate
-    if (!instanceType->getAs<TupleType>()) {
-      auto ctors = CS->TC.lookupConstructors(CS->DC, instanceType);
-      for (auto ctor : ctors) {
-        if (auto fnType = ctor->getType()->getAs<AnyFunctionType>()) {
-          // skip type argument
-          if (auto fnType2 = fnType->getResult()->getAs<AnyFunctionType>()) {
-            paramLists.push_back(fnType2->getInput());
-          }
-        }
-      }
-    }
-    if (paramLists.size() > 1)
-      isOverloadedFn = true;
-
   } else if (auto UDE = dyn_cast<UnresolvedDotExpr>(fnExpr)) {
     overloadName = UDE->getName().str().str();
   } else if (isa<UnresolvedConstructorExpr>(fnExpr)) {
@@ -2724,7 +2690,7 @@ bool FailureDiagnosis::visitCallExpr(CallExpr *callExpr) {
     isInvalidTrailingClosureTarget = !isa<ClosureExpr>(unwrappedExpr);
   }
   // TODO: Handle dot_syntax_call_expr "fn" as a non-closure value.
-
+  // TODO: need a concept of an uncurry level.
 
   Type argType;
 
@@ -2746,7 +2712,8 @@ bool FailureDiagnosis::visitCallExpr(CallExpr *callExpr) {
       SmallVector<TupleTypeElt, 4> resultElts;
 
       for (unsigned i = 0, e = TE->getNumElements(); i != e; i++) {
-        auto elType = getTypeOfTypeCheckedIndependentSubExpression(TE->getElement(i));
+        auto elType =
+          getTypeOfTypeCheckedIndependentSubExpression(TE->getElement(i));
         if (!elType)
           return true; // already diagnosed.
 
@@ -2820,22 +2787,9 @@ bool FailureDiagnosis::visitCallExpr(CallExpr *callExpr) {
   }
 
   // Did the user intend on invoking a different overload?
-  if (!paramLists.empty()) {
-    if (!isOverloadedFn) {
-      std::string paramString = "";
-
-      if (!paramLists[0]->isVoid()) {
-        paramString = getTypeListString(paramLists[0]);
-        
-        CS->TC.diagnose(argExpr->getLoc(),
-                        diag::expected_certain_args,
-                        paramString);
-      }
-    } else {
-      suggestPotentialOverloads(overloadName, fnExpr->getLoc(),
-                                paramLists, argType);
-    }
-  }
+  suggestPotentialOverloads(overloadName, fnExpr->getLoc(),
+                            Candidates, candidateCloseness,
+                            /*isCallExpr*/true);
 
   expr->setType(ErrorType::get(CS->getASTContext()));
   return true;

Diff for: test/1_stdlib/UnicodeScalarDiagnostics.swift

@@ -16,12 +16,12 @@ func test_UnicodeScalarDoesNotImplementArithmetic(us: UnicodeScalar, i: Int) {
 
   let c1 = us + i // expected-error {{binary operator '+' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{overloads for '+' exist with these partially matching parameter lists:}}
   let c2 = us - i // expected-error {{binary operator '-' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{overloads for '-' exist with these partially matching parameter lists:}}
-  let c3 = us * i // expected-error {{binary operator '*' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{overloads for '*' exist with these partially matching parameter lists:}}
-  let c4 = us / i // expected-error {{binary operator '/' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{overloads for '/' exist with these partially matching parameter lists:}}
+  let c3 = us * i // expected-error {{binary operator '*' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{expected an argument list of type '(Int, Int)'}}
+  let c4 = us / i // expected-error {{binary operator '/' cannot be applied to operands of type 'UnicodeScalar' and 'Int'}} expected-note{{expected an argument list of type '(Int, Int)'}}
 
   let d1 = i + us // expected-error {{binary operator '+' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{overloads for '+' exist with these partially matching parameter lists:}}
-  let d2 = i - us // expected-error {{binary operator '-' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{overloads for '-' exist with these partially matching parameter lists:}}
-  let d3 = i * us // expected-error {{binary operator '*' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{overloads for '*' exist with these partially matching parameter lists:}}
-  let d4 = i / us // expected-error {{binary operator '/' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{overloads for '/' exist with these partially matching parameter lists:}}
+  let d2 = i - us // expected-error {{binary operator '-' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{expected an argument list of type '(Int, Int)'}}
+  let d3 = i * us // expected-error {{binary operator '*' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{expected an argument list of type '(Int, Int)'}}
+  let d4 = i / us // expected-error {{binary operator '/' cannot be applied to operands of type 'Int' and 'UnicodeScalar'}} expected-note{{expected an argument list of type '(Int, Int)'}}
 }
 

Diff for: test/ClangModules/cfuncs_parse.swift

@@ -7,6 +7,7 @@ import cfuncs
 func test_cfunc1(i: Int) {
   cfunc1() // okay
   cfunc1(i) // expected-error{{cannot invoke 'cfunc1' with an argument list of type '(Int)'}}
+  // expected-note @-1 {{expected an argument list of type '()'}}
 }
 
 func test_cfunc2(i: Int) {

Diff for: test/ClangModules/objc_diags.swift

@@ -6,4 +6,5 @@ import ObjectiveC
 
 func instanceMethod(b: B) {
   b.method(1, 2.5) // expected-error {{cannot invoke 'method' with an argument list of type '(Int, Double)'}}
+  // expected-note @-1 {{expected an argument list of type '(Int32, onExtB: Double)'}}
 }

Diff for: test/ClangModules/objc_factory_method.swift

@@ -20,6 +20,7 @@ func testInstanceTypeFactoryMethodInherited() {
   _ = NSObjectFactorySub(double: 314159)
   _ = NSObjectFactorySub(float: 314159) // expected-error{{incorrect argument label in call (have 'float:', expected 'integer:')}}
   let a = NSObjectFactorySub(buildingWidgets: ()) // expected-error{{cannot find an initializer for type 'NSObjectFactorySub' that accepts an argument list of type '(buildingWidgets: ())'}}
+  // expected-note @-1 {{overloads for 'NSObjectFactorySub' exist with these partially matching parameter lists: (integer: Int), (double: Double), ()}}
   _ = a
 }
 

Diff for: test/ClangModules/objc_implicit_properties.swift

@@ -18,11 +18,23 @@ func implicitProperties(obj: ImplicitProperties, other: AnyObject) {
 
 func badImplicitProperties(obj: BadImplicitProperties) {
   acceptsInt(obj.nonVoidReturn) // expected-error {{cannot find an overload for 'acceptsInt' that accepts an argument list of type '(() -> Int32)'}}
+  // expected-note @-1 {{overloads for 'acceptsInt' exist with these partially matching parameter lists: (Int), (UInt)}}
+  
   acceptsInt(obj.nonMatchingType) // expected-error {{cannot find an overload for 'acceptsInt' that accepts an argument list of type '(() -> Int32)'}}
+  // expected-note @-1 {{overloads for 'acceptsInt' exist with these partially matching parameter lists: (Int), (UInt)}}
+  
   acceptsInt(obj.wrongGetterArgs) // expected-error {{cannot find an overload for 'acceptsInt' that accepts an argument list of type '((Int32) -> Int32)'}}
+  // expected-note @-1 {{overloads for 'acceptsInt' exist with these partially matching parameter lists: (Int), (UInt)}}
+
   acceptsInt(obj.wrongSetterArgs) // expected-error {{cannot find an overload for 'acceptsInt' that accepts an argument list of type '(() -> Int32)'}}
+  // expected-note @-1 {{overloads for 'acceptsInt' exist with these partially matching parameter lists: (Int), (UInt)}}
+
   acceptsInt(obj.wrongSetterArgs2) // expected-error {{cannot find an overload for 'acceptsInt' that accepts an argument list of type '(() -> Int32)'}}
+  // expected-note @-1 {{overloads for 'acceptsInt' exist with these partially matching parameter lists: (Int), (UInt)}}
+
   acceptsInt(obj.getterOnly) // expected-error {{cannot find an overload for 'acceptsInt' that accepts an argument list of type '(() -> Int32)'}}
+  // expected-note @-1 {{overloads for 'acceptsInt' exist with these partially matching parameter lists: (Int), (UInt)}}
+
   acceptsInt(obj.setterOnly) // expected-error {{'BadImplicitProperties' does not have a member named 'setterOnly'}}
 
   // But we should still import all of the methods as methods.

Diff for: test/ClangModules/objc_implicit_with.swift

@@ -36,6 +36,7 @@ func testInstanceTypeFactoryMethodInherited() {
   // FIXME: Awful diagnostic
   _ = NSObjectFactorySub(float: 314159) // expected-error{{incorrect argument label in call (have 'float:', expected 'integer:')}}
   let a = NSObjectFactorySub(buildingWidgets: ()) // expected-error{{cannot find an initializer for type 'NSObjectFactorySub' that accepts an argument list of type '(buildingWidgets: ())'}}
+  // expected-note @-1 {{overloads for 'NSObjectFactorySub' exist with these partially matching parameter lists: (integer: Int), (double: Double), ()}}
   _ = a
 }
 

Diff for: test/ClangModules/objc_parse.swift

@@ -71,6 +71,7 @@ func classMethods(b: B, other: NSObject) {
   B.description()
   B.instanceTakesObjectClassTakesFloat(2.0)
   B.instanceTakesObjectClassTakesFloat(other) // expected-error{{cannot invoke 'instanceTakesObjectClassTakesFloat' with an argument list of type '(NSObject)'}}
+  // expected-note @-1 {{expected an argument list of type '(Float)'}}
 
   // Call an instance method of NSObject.
   var c: AnyClass = B.myClass() // no-warning