[Diagnostics] Remove ContextualFailure::diagnoseMissingFunctionCall.

Instead, always diagnose missing call errors via MissingCallFailure.

Author: hborla

lib/Sema/CSDiagnostics.cpp

@@ -2240,9 +2240,6 @@ bool ContextualFailure::diagnoseAsError() {
     return false;
   }
 
-  if (diagnoseMissingFunctionCall())
-    return true;
-
   if (diagnoseExtraneousAssociatedValues())
     return true;
 
@@ -2643,36 +2640,6 @@ void ContextualFailure::tryFixIts(InFlightDiagnostic &diagnostic) const {
     return;
 }
 
-bool ContextualFailure::diagnoseMissingFunctionCall() const {
-  // Don't suggest inserting a function call if the function expression
-  // isn't written explicitly in the source code.
-  auto *anchor = getAsExpr(simplifyLocatorToAnchor(getLocator()));
-  if (!anchor || anchor->isImplicit())
-    return false;
-
-  if (getLocator()
-      ->isLastElement<LocatorPathElt::UnresolvedMemberChainResult>())
-    return false;
-
-  auto *srcFT = getFromType()->getAs<FunctionType>();
-  if (!srcFT ||
-      !(srcFT->getParams().empty() ||
-        getLocator()->isLastElement<LocatorPathElt::PatternMatch>()))
-    return false;
-
-  auto toType = getToType();
-  if (toType->is<AnyFunctionType>() ||
-      !TypeChecker::isConvertibleTo(srcFT->getResult(), toType, getDC()))
-    return false;
-
-  emitDiagnostic(diag::missing_nullary_call, srcFT->getResult())
-      .highlight(getSourceRange())
-      .fixItInsertAfter(getSourceRange().End, "()");
-
-  tryComputedPropertyFixIts();
-  return true;
-}
-
 bool ContextualFailure::diagnoseExtraneousAssociatedValues() const {
   if (auto match =
           getLocator()->getLastElementAs<LocatorPathElt::PatternMatch>()) {
@@ -3094,7 +3061,7 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
   return true;
 }
 
-void ContextualFailure::tryComputedPropertyFixIts() const {
+void MissingCallFailure::tryComputedPropertyFixIts() const {
   if (!isExpr<ClosureExpr>(getAnchor()))
     return;
 
@@ -3305,7 +3272,8 @@ bool MissingCallFailure::diagnoseAsError() {
   if (isExpr<KeyPathExpr>(anchor))
     return false;
 
-  auto path = getLocator()->getPath();
+  auto *locator = getLocator();
+  auto path = locator->getPath();
   if (!path.empty()) {
     const auto &last = path.back();
 
@@ -3314,8 +3282,17 @@ bool MissingCallFailure::diagnoseAsError() {
     case ConstraintLocator::ApplyArgToParam: {
       auto type = getType(anchor)->lookThroughAllOptionalTypes();
       auto fnType = type->castTo<FunctionType>();
+
+      if (MissingArgumentsFailure::isMisplacedMissingArgument(getSolution(), locator)) {
+        ArgumentMismatchFailure failure(
+            getSolution(), fnType, fnType->getResult(), locator);
+        return failure.diagnoseMisplacedMissingArgument();
+      }
+
       emitDiagnostic(diag::missing_nullary_call, fnType->getResult())
+          .highlight(getSourceRange())
           .fixItInsertAfter(insertLoc, "()");
+      tryComputedPropertyFixIts();
       return true;
     }
 
@@ -4708,8 +4685,9 @@ bool MissingArgumentsFailure::isMisplacedMissingArgument(
   auto *argLoc = solution.getConstraintLocator(
       callLocator, LocatorPathElt::ApplyArgToParam(0, 0, argFlags));
 
-  if (!(hasFixFor(FixKind::AllowArgumentTypeMismatch, argLoc) &&
-        hasFixFor(FixKind::AddMissingArguments, callLocator)))
+  bool hasArgumentMismatch = hasFixFor(FixKind::AllowArgumentTypeMismatch, argLoc) ||
+                             hasFixFor(FixKind::InsertCall, argLoc);
+  if (!(hasArgumentMismatch && hasFixFor(FixKind::AddMissingArguments, callLocator)))
     return false;
 
   auto *anchorExpr = getAsExpr(anchor);

lib/Sema/CSDiagnostics.h

@@ -633,10 +633,6 @@ class ContextualFailure : public FailureDiagnostic {
   /// Diagnose failed conversion in a `CoerceExpr`.
   bool diagnoseCoercionToUnrelatedType() const;
 
-  /// If we're trying to convert something of type "() -> T" to T,
-  /// then we probably meant to call the value.
-  bool diagnoseMissingFunctionCall() const;
-
   /// Diagnose cases where a pattern tried to match associated values but
   /// the enum case had none.
   bool diagnoseExtraneousAssociatedValues() const;
@@ -687,10 +683,6 @@ class ContextualFailure : public FailureDiagnostic {
     return resolveType(rawType)->getWithoutSpecifierType();
   }
 
-  /// Try to add a fix-it to convert a stored property into a computed
-  /// property
-  void tryComputedPropertyFixIts() const;
-
   bool isIntegerType(Type type) const {
     return conformsToKnownProtocol(
         type, KnownProtocolKind::ExpressibleByIntegerLiteral);
@@ -1050,6 +1042,10 @@ class NonOptionalUnwrapFailure final : public FailureDiagnostic {
 };
 
 class MissingCallFailure final : public FailureDiagnostic {
+  /// Try to add a fix-it to convert a stored property into a computed
+  /// property
+  void tryComputedPropertyFixIts() const;
+
 public:
   MissingCallFailure(const Solution &solution, ConstraintLocator *locator)
       : FailureDiagnostic(solution, locator) {}
@@ -1958,6 +1954,15 @@ class ArgumentMismatchFailure : public ContextualFailure {
   /// result value.
   bool diagnoseKeyPathAsFunctionResultMismatch() const;
 
+  /// Situations like this:
+  ///
+  /// func foo(_: Int, _: String) {}
+  /// foo("")
+  ///
+  /// Are currently impossible to fix correctly,
+  /// so we have to attend to that in diagnostics.
+  bool diagnoseMisplacedMissingArgument() const;
+
 protected:
   /// \returns The position of the argument being diagnosed, starting at 1.
   unsigned getArgPosition() const { return Info.getArgPosition(); }
@@ -2042,15 +2047,6 @@ class ArgumentMismatchFailure : public ContextualFailure {
   ParameterTypeFlags getParameterFlagsAtIndex(unsigned idx) const {
     return Info.getParameterFlagsAtIndex(idx);
   }
-
-  /// Situations like this:
-  ///
-  /// func foo(_: Int, _: String) {}
-  /// foo("")
-  ///
-  /// Are currently impossible to fix correctly,
-  /// so we have to attend to that in diagnostics.
-  bool diagnoseMisplacedMissingArgument() const;
 };
 
 /// Replace a coercion ('as') with a runtime checked cast ('as!' or 'as?').

lib/Sema/CSSimplify.cpp

@@ -3664,6 +3664,16 @@ bool ConstraintSystem::repairFailures(
     if (!anchor || anchor->isImplicit())
       return false;
 
+    if (isArgumentOfPatternMatchingOperator(loc))
+      return false;
+
+    // Don't attempt this fix for trailing closures.
+    if (auto elt = loc->getLastElementAs<LocatorPathElt::ApplyArgToParam>()) {
+      auto argumentList = getArgumentList(loc);
+      if (argumentList->isTrailingClosureIndex(elt->getArgIdx()))
+        return false;
+    }
+
     // If argument is a function type and all of its parameters have
     // default values, let's see whether error is related to missing
     // explicit call.
@@ -3703,7 +3713,14 @@ bool ConstraintSystem::repairFailures(
         convertTo->isAny())
       return false;
 
-    auto result = matchTypes(resultType, dstType, ConstraintKind::Conversion,
+    ConstraintKind matchKind;
+    if (resultType->is<TypeVariableType>()) {
+      matchKind = ConstraintKind::Equal;
+    } else {
+      matchKind = ConstraintKind::Conversion;
+    }
+
+    auto result = matchTypes(resultType, dstType, matchKind,
                              TypeMatchFlags::TMF_ApplyingFix, locator);
 
     if (result.isSuccess()) {
@@ -4540,6 +4557,9 @@ bool ConstraintSystem::repairFailures(
 
   case ConstraintLocator::ClosureBody:
   case ConstraintLocator::ClosureResult: {
+    if (repairByInsertingExplicitCall(lhs, rhs))
+      break;
+
     if (repairViaOptionalUnwrap(*this, lhs, rhs, matchKind, conversionsOrFixes,
                                 locator))
       return true;

test/type/types.swift

@@ -16,7 +16,7 @@ var d2 : () -> Int = { 4 }
 
 var d3 : () -> Float = { 4 }
 
-var d4 : () -> Int = { d2 }  // expected-error{{function produces expected type 'Int'; did you mean to call it with '()'?}} {{26-26=()}}
+var d4 : () -> Int = { d2 }  // expected-error{{function 'd2' was used as a property; add () to call it}} {{26-26=()}}
 
 if #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) {
   var e0 : [Int]