Merge pull request swiftlang#74564 from gottesmm/pr-9be87019f95149167c2e03043b7a86b82f9d282c

Follow up fixes with feedback from swiftlang#74129

Author: gottesmm

include/swift/Sema/CSFix.h

@@ -24,6 +24,7 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Debug.h"
+#include "swift/Sema/Constraint.h"
 #include "swift/Sema/ConstraintLocator.h"
 #include "swift/Sema/FixBehavior.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -479,8 +480,8 @@ enum class FixKind : uint8_t {
   /// parameter.
   ///
   /// 2. Where we have a function that expects a function typed parameter with a
-  /// sending result, but is passed a function typeed parameter without a
-  /// sending result.
+  /// sending result, but is passed a function typed parameter without a sending
+  /// result.
   AllowSendingMismatch,
 };
 
@@ -2636,26 +2637,16 @@ class TreatEphemeralAsNonEphemeral final : public AllowArgumentMismatch {
 /// non-Sendable is safe to transfer onto other situations. The caller though
 /// that this is being sent to does not enforce that invariants within its body.
 class AllowSendingMismatch final : public ContextualMismatch {
-public:
-  enum class Kind {
-    Parameter,
-    Result,
-  };
-
-private:
-  Kind kind;
-
   AllowSendingMismatch(ConstraintSystem &cs, Type argType, Type paramType,
-                       ConstraintLocator *locator, Kind kind,
-                       FixBehavior fixBehavior)
+                       ConstraintLocator *locator, FixBehavior fixBehavior)
       : ContextualMismatch(cs, FixKind::AllowSendingMismatch, argType,
-                           paramType, locator, fixBehavior),
-        kind(kind) {}
+                           paramType, locator, fixBehavior) {}
 
 public:
   std::string getName() const override {
-    return "treat a function argument with sending parameter as a function "
-           "argument without sending parameters";
+    return "treat a function argument with sending parameters and results as a "
+           "function "
+           "argument without sending parameters and results";
   }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
@@ -2664,9 +2655,8 @@ class AllowSendingMismatch final : public ContextualMismatch {
     return diagnose(*commonFixes.front().first);
   }
 
-  static AllowSendingMismatch *create(ConstraintSystem &cs,
-                                      ConstraintLocator *locator, Type srcType,
-                                      Type dstType, Kind kind);
+  static AllowSendingMismatch *create(ConstraintSystem &cs, Type srcType,
+                                      Type dstType, ConstraintLocator *locator);
 
   static bool classof(const ConstraintFix *fix) {
     return fix->getKind() == FixKind::AllowSendingMismatch;

lib/Sema/CSDiagnostics.cpp

@@ -7919,21 +7919,25 @@ bool NonEphemeralConversionFailure::diagnoseAsError() {
   return true;
 }
 
-bool SendingOnFunctionParameterMismatchFail::diagnoseAsError() {
-  emitDiagnosticAt(getLoc(), diag::sending_function_wrong_sending,
-                   getFromType(), getToType())
+bool SendingMismatchFailure::diagnoseAsError() {
+  if (getLocator()->getLastElementAs<LocatorPathElt::FunctionArgument>())
+    return diagnoseArgFailure();
+  return diagnoseResultFailure();
+}
+
+bool SendingMismatchFailure::diagnoseArgFailure() {
+  emitDiagnostic(diag::sending_function_wrong_sending, getFromType(),
+                 getToType())
       .warnUntilSwiftVersion(6);
-  emitDiagnosticAt(getLoc(),
-                   diag::sending_function_param_with_sending_param_note);
+  emitDiagnostic(diag::sending_function_param_with_sending_param_note);
   return true;
 }
 
-bool SendingOnFunctionResultMismatchFailure::diagnoseAsError() {
-  emitDiagnosticAt(getLoc(), diag::sending_function_wrong_sending,
-                   getFromType(), getToType())
+bool SendingMismatchFailure::diagnoseResultFailure() {
+  emitDiagnostic(diag::sending_function_wrong_sending, getFromType(),
+                 getToType())
       .warnUntilSwiftVersion(6);
-  emitDiagnosticAt(getLoc(),
-                   diag::sending_function_result_with_sending_param_note);
+  emitDiagnostic(diag::sending_function_result_with_sending_param_note);
   return true;
 }
 

lib/Sema/CSDiagnostics.h

@@ -2292,26 +2292,17 @@ class NonEphemeralConversionFailure final : public ArgumentMismatchFailure {
   void emitSuggestionNotes() const;
 };
 
-class SendingOnFunctionParameterMismatchFail final : public ContextualFailure {
+class SendingMismatchFailure final : public ContextualFailure {
 public:
-  SendingOnFunctionParameterMismatchFail(const Solution &solution, Type srcType,
-                                         Type dstType,
-                                         ConstraintLocator *locator,
-                                         FixBehavior fixBehavior)
+  SendingMismatchFailure(const Solution &solution, Type srcType, Type dstType,
+                         ConstraintLocator *locator, FixBehavior fixBehavior)
       : ContextualFailure(solution, srcType, dstType, locator, fixBehavior) {}
 
   bool diagnoseAsError() override;
-};
-
-class SendingOnFunctionResultMismatchFailure final : public ContextualFailure {
-public:
-  SendingOnFunctionResultMismatchFailure(const Solution &solution, Type srcType,
-                                         Type dstType,
-                                         ConstraintLocator *locator,
-                                         FixBehavior fixBehavior)
-      : ContextualFailure(solution, srcType, dstType, locator, fixBehavior) {}
 
-  bool diagnoseAsError() override;
+private:
+  bool diagnoseArgFailure();
+  bool diagnoseResultFailure();
 };
 
 class AssignmentTypeMismatchFailure final : public ContextualFailure {

lib/Sema/CSFix.cpp

@@ -1848,30 +1848,19 @@ std::string TreatEphemeralAsNonEphemeral::getName() const {
 
 bool AllowSendingMismatch::diagnose(const Solution &solution,
                                     bool asNote) const {
-  switch (kind) {
-  case Kind::Parameter: {
-    SendingOnFunctionParameterMismatchFail failure(
-        solution, getFromType(), getToType(), getLocator(), fixBehavior);
-    return failure.diagnose(asNote);
-  }
-  case Kind::Result: {
-    SendingOnFunctionResultMismatchFailure failure(
-        solution, getFromType(), getToType(), getLocator(), fixBehavior);
-    return failure.diagnose(asNote);
-  }
-  }
-  llvm_unreachable("Covered switch isn't covered?!");
+  SendingMismatchFailure failure(solution, getFromType(), getToType(),
+                                 getLocator(), fixBehavior);
+  return failure.diagnose(asNote);
 }
 
 AllowSendingMismatch *AllowSendingMismatch::create(ConstraintSystem &cs,
-                                                   ConstraintLocator *locator,
                                                    Type srcType, Type dstType,
-                                                   Kind kind) {
+                                                   ConstraintLocator *locator) {
   auto fixBehavior = cs.getASTContext().LangOpts.isSwiftVersionAtLeast(6)
                          ? FixBehavior::Error
                          : FixBehavior::DowngradeToWarning;
   return new (cs.getAllocator())
-      AllowSendingMismatch(cs, srcType, dstType, locator, kind, fixBehavior);
+      AllowSendingMismatch(cs, srcType, dstType, locator, fixBehavior);
 }
 
 bool SpecifyBaseTypeForContextualMember::diagnose(const Solution &solution,

lib/Sema/CSSimplify.cpp

@@ -3239,9 +3239,8 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   // () -> sending T can be a subtype of () -> T... but not vis-a-versa.
   if (func1->hasSendingResult() != func2->hasSendingResult() &&
       (!func1->hasSendingResult() || kind < ConstraintKind::Subtype)) {
-    auto *fix = AllowSendingMismatch::create(
-        *this, getConstraintLocator(locator), func1, func2,
-        AllowSendingMismatch::Kind::Result);
+    auto *fix = AllowSendingMismatch::create(*this, func1, func2,
+                                             getConstraintLocator(locator));
     if (recordFix(fix))
       return getTypeMatchFailure(locator);
   }
@@ -3681,8 +3680,7 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
       if (func1Param.getParameterFlags().isSending() &&
           !func2Param.getParameterFlags().isSending()) {
         auto *fix = AllowSendingMismatch::create(
-            *this, getConstraintLocator(argumentLocator), func1, func2,
-            AllowSendingMismatch::Kind::Parameter);
+            *this, func1, func2, getConstraintLocator(argumentLocator));
         if (recordFix(fix))
           return getTypeMatchFailure(argumentLocator);
       }