reimplement the "function produces expected type 'XYZ'; did you mean to call it with '()'?"

fixit hint in CSDiags instead of being a FixKind.  This resolves a number of issues with
it, particularly that it didn't actually check to see if the function in question takes
a () argument or not.  

This fixes:
<rdar://problem/21692808> QoI: Incorrect 'add ()' fixit with trailing closure

among other issues.



Swift SVN r31728

Author: lattner

Diff for: lib/Sema/CSApply.cpp

@@ -5803,29 +5803,6 @@ bool ConstraintSystem::applySolutionFix(Expr *expr,
   case FixKind::None:
     llvm_unreachable("no-fix marker should never make it into solution");
 
-  case FixKind::NullaryCall: {
-    // Dig for the function we want to call.
-    auto type = solution.simplifyType(TC, affected->getType())
-                  ->getRValueType();
-    if (auto tupleTy = type->getAs<TupleType>()) {
-      if (tupleTy->getElementTypes().size()) {
-        if (auto tuple = dyn_cast<TupleExpr>(affected))
-          affected = tuple->getElement(0);
-        type = tupleTy->getElement(0).getType()->getRValueType();
-      }
-    }
-
-    if (auto optTy = type->getAnyOptionalObjectType())
-      type = optTy;
-
-    if (type->is<AnyFunctionType>())
-      type = type->castTo<AnyFunctionType>()->getResult();
-    
-    TC.diagnose(affected->getLoc(), diag::missing_nullary_call, type)
-      .fixItInsertAfter(affected->getEndLoc(), "()");
-    return true;
-  }
-
   case FixKind::RemoveNullaryCall:
     if (auto apply = dyn_cast<ApplyExpr>(affected)) {
       auto type = solution.simplifyType(TC, apply->getFn()->getType())

Diff for: lib/Sema/CSDiag.cpp

@@ -2862,6 +2862,18 @@ bool FailureDiagnosis::diagnoseContextualConversionError() {
     return false;
   }
 
+  // If we're trying to convert something of type "() -> T" to T, then we
+  // probably meant to call the value.
+  if (auto srcFT = exprType->getAs<AnyFunctionType>()) {
+    if (srcFT->getInput()->isVoid() &&
+        CS->TC.isConvertibleTo(srcFT->getResult(), contextualType, CS->DC)) {
+      diagnose(expr->getLoc(), diag::missing_nullary_call, srcFT->getResult())
+        .highlight(expr->getSourceRange())
+        .fixItInsertAfter(expr->getEndLoc(), "()");
+      return true;
+    }
+  }
+  
   // When complaining about conversion to a protocol type, complain about
   // conformance instead of "conversion".
   if (contextualType->is<ProtocolType>() ||

Diff for: lib/Sema/CSSimplify.cpp

@@ -900,20 +900,9 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
                                      ConstraintLocatorBuilder locator) {
   // An @autoclosure function type can be a subtype of a
   // non-@autoclosure function type.
-  if (func1->isAutoClosure() != func2->isAutoClosure()) {
-    if (func2->isAutoClosure() || kind < TypeMatchKind::Subtype) {
-      // If the second type is an autoclosure and the first type appears to
-      // accept no arguments, try to add the ().
-      if (func2->isAutoClosure() && shouldAttemptFixes() &&
-          kind >= TypeMatchKind::Conversion &&
-          isFunctionTypeAcceptingNoArguments(func1)) {
-        unsigned subFlags = (flags | TMF_GenerateConstraints) & ~TMF_ApplyingFix;
-        return simplifyFixConstraint(FixKind::NullaryCall, func1, func2, kind,
-                                     subFlags, locator);
-      }
-      return SolutionKind::Error;
-    }
-  }
+  if (func1->isAutoClosure() != func2->isAutoClosure() &&
+      (func2->isAutoClosure() || kind < TypeMatchKind::Subtype))
+    return SolutionKind::Error;
 
   // A non-throwing function can be a subtype of a throwing function.
   if (func1->throws() != func2->throws()) {
@@ -2014,12 +2003,6 @@ ConstraintSystem::matchTypes(Type type1, Type type2, TypeMatchKind kind,
       !(flags & TMF_ApplyingFix) && kind >= TypeMatchKind::Conversion) {
     Type objectType1 = type1->getRValueObjectType();
 
-    // If the source type is a function type that could be applied with (),
-    // try it.
-    if (isFunctionTypeAcceptingNoArguments(objectType1)) {
-      conversionsOrFixes.push_back(FixKind::NullaryCall);
-    }
-
     // If we have an optional type, try to force-unwrap it.
     // FIXME: Should we also try '?'?
     if (objectType1->getOptionalObjectType()) {
@@ -4284,29 +4267,6 @@ ConstraintSystem::simplifyFixConstraint(Fix fix,
   case FixKind::None:
     return matchTypes(type1, type2, matchKind, subFlags, locator);
 
-  case FixKind::NullaryCall: {
-    // Assume that '()' was applied to the first type.
-
-    // If the function was actually in a tuple, tuple'ify the
-    // FIXME: This is yet another awful hack due to one-element tuples.
-    auto funcTy = type1->getRValueType();
-    Identifier nameToAdd;
-    if (auto tupleTy = funcTy->getAs<TupleType>()) {
-      int scalarIdx = tupleTy->getElementForScalarInit();
-      nameToAdd = tupleTy->getElement(scalarIdx).getName();
-      funcTy = tupleTy->getElementType(scalarIdx);
-    }
-
-    if (auto optObjectTy = funcTy->getAnyOptionalObjectType())
-      funcTy = optObjectTy;
-
-    auto resultTy = funcTy->castTo<AnyFunctionType>()->getResult();
-    if (!nameToAdd.empty())
-      resultTy = TupleType::get(TupleTypeElt(resultTy, nameToAdd),
-                                  getASTContext());
-    return matchTypes(resultTy, type2, matchKind, subFlags, locator);
-  }
-
   case FixKind::RemoveNullaryCall:
     llvm_unreachable("Always applied directly");
 

Diff for: lib/Sema/Constraint.cpp

@@ -435,8 +435,6 @@ StringRef Fix::getName(FixKind kind) {
   switch (kind) {
   case FixKind::None:
     return "prevent fixes";
-  case FixKind::NullaryCall:
-    return "fix: add nullary call";
   case FixKind::ForceOptional:
     return "fix: force optional";
   case FixKind::ForceDowncast:

Diff for: test/Constraints/diagnostics.swift

@@ -455,8 +455,7 @@ let _ : Color = .rainbow(42)  // expected-error {{cannot convert value of type '
 
 let _ : (Int, Float) = (42.0, 12)  // expected-error {{cannot convert value of type 'Double' to specified type 'Int'}}
 
-// FIXME: Why two errors?
-let _ : Color = .rainbow  // expected-error 2 {{function produces expected type 'Color'; did you mean to call it with '()'?}}
+let _ : Color = .rainbow  // expected-error {{contextual member 'rainbow' expects argument of type '()'}}
 
 let _: Color = .overload(a : 1.0)  // expected-error {{cannot convert value of type 'Double' to expected argument type 'Int'}}
 let _: Color = .overload(1.0)  // expected-error {{ambiguous reference to member 'overload'}}
@@ -597,3 +596,12 @@ extension Array {
 func safeAssign<T: RawRepresentable>(inout lhs: T) -> Bool {}  // expected-note {{in call to function 'safeAssign'}}
 let a = safeAssign // expected-error {{generic parameter 'T' could not be inferred}}
 
+
+// <rdar://problem/21692808> QoI: Incorrect 'add ()' fixit with trailing closure
+func foo() -> [Int] {
+  return Array <Int> (count: 1) {
+    return 1
+  }
+}
+
+

Diff for: test/Constraints/fixes.swift

@@ -14,8 +14,8 @@ func f4() -> B { }
 func f5(a: A) { }
 func f6(a: A, _: Int) { }
 
-func createB() -> B { }
-func createB(i: Int) -> B { }
+func createB() -> B { }  // expected-note {{found this candidate}}
+func createB(i: Int) -> B { } // expected-note {{found this candidate}}
 
 func f7(a: A, _: () -> Int) -> B { }
 func f7(a: A, _: Int) -> Int { }
@@ -25,8 +25,8 @@ func forgotCall() {
   // Simple cases
   var x: Int
   x = f1 // expected-error{{function produces expected type 'Int'; did you mean to call it with '()'?}}{{9-9=()}}
-  x = f2 // expected-error{{function produces expected type 'Int'; did you mean to call it with '()'?}}{{9-9=()}}
-  x = f3 // expected-error{{function produces expected type 'Int'; did you mean to call it with '()'?}}{{9-9=()}}
+  x = f2 // expected-error{{cannot assign value of type '(Int) -> Int' to type 'Int'}}
+  x = f3 // expected-error{{cannot assign value of type '(Int...) -> Int' to type 'Int'}}
 
   // With a supertype conversion
   var a = A()
@@ -35,13 +35,13 @@ func forgotCall() {
   // As a call
   f5(f4) // expected-error{{function produces expected type 'B'; did you mean to call it with '()'?}}{{8-8=()}}
   f6(f4, f2) // expected-error{{function produces expected type 'B'; did you mean to call it with '()'?}}{{8-8=()}}
-  // expected-error @-1{{function produces expected type 'Int'; did you mean to call it with '()'?}}{{12-12=()}}
 
   // With overloading: only one succeeds.
-  a = createB // expected-error{{function produces expected type 'B'; did you mean to call it with '()'?}}{{14-14=()}}
+  a = createB // expected-error{{ambiguous reference to member 'createB'}}
 
   // With overloading, pick the fewest number of fixes.
-  var b = f7(f4, f1) // expected-error{{function produces expected type 'B'; did you mean to call it with '()'?}}{{16-16=()}}
+  var b = f7(f4, f1) // expected-error{{cannot invoke 'f7' with an argument list of type '(() -> B, () -> Int)'}}
+  // expected-note @-1 {{expected an argument list of type '(A, () -> Int)'}}
   b.iAmAB()
 }
 

Diff for: test/stmt/statements.swift

@@ -402,9 +402,8 @@ func test_is_as_patterns() {
 // <rdar://problem/21387308> Fuzzing SourceKit: crash in Parser::parseStmtForEach(...)
 func matching_pattern_recursion() {
   switch 42 {
-  // FIXME: this is a terrible diagnostic
-  case {  // expected-error {{function produces expected type 'Range<Int>'; did you mean to call it with '()'?}} {{4-4=()}}
-      for i in zs {
+  case {  // expected-error {{expression pattern of type '() -> ()' cannot match values of type 'Int'}}
+      for i in zs {  // expected-error {{use of unresolved identifier 'zs'}}
       }
   }: break
   }