Check sending in the process of diagnosing NonSendable types

Author: stzn

lib/Sema/TypeCheckConcurrency.cpp

@@ -1184,11 +1184,8 @@ bool swift::diagnoseNonSendableTypesInReference(
       // Check params of this function or subscript override for sendability
       for (auto param : *paramList) {
         Type paramType = param->getInterfaceType().subst(subs);
-        if (param->isSending() && !paramType->hasError()) {
-          continue;
-        }
-        if (diagnoseNonSendableTypes(
-                paramType, fromDC, derivedConformanceType, refLoc,
+        if (diagnoseNonSendableTypesWithSendingCheck(
+                param, paramType, fromDC, derivedConformanceType, refLoc,
                 diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
                 getSendableParamDiag(refKind), decl, getActorIsolation()))
           return true;
@@ -1198,27 +1195,19 @@ bool swift::diagnoseNonSendableTypesInReference(
     // Check the result type of a function or subscript.
     if (funcCheckOptions.contains(FunctionCheckKind::Results)) {
       Type resultType;
-      bool hasSendingResult;
       if (auto func = dyn_cast<FuncDecl>(decl)) {
         resultType = func->getResultInterfaceType().subst(subs);
-        hasSendingResult = func->hasSendingResult();
         decl = func;
       } else if (auto subscript = dyn_cast<SubscriptDecl>(decl)) {
         resultType = subscript->getElementInterfaceType().subst(subs);
-        hasSendingResult = isa<SendingTypeRepr>(subscript->getResultTypeRepr());
       }
       if (!resultType) {
         return false;
       }
-      auto diag = getSendableResultDiag(refKind);
-      if (diag.ID == diag::non_sendable_result_in_witness.ID &&
-          hasSendingResult && !resultType->hasError()) {
-        return false;
-      }
-      if (diagnoseNonSendableTypes(
-              resultType, fromDC, derivedConformanceType, refLoc,
-              diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc, diag, decl,
-              getActorIsolation()))
+      if (diagnoseNonSendableTypesWithSendingCheck(
+              decl, resultType, fromDC, derivedConformanceType, refLoc,
+              diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
+              getSendableResultDiag(refKind), decl, getActorIsolation()))
         return true;
     }
 

lib/Sema/TypeCheckConcurrency.h

@@ -23,6 +23,7 @@
 #include "swift/AST/Expr.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Type.h"
+#include "swift/AST/TypeRepr.h"
 #include "swift/Sema/Concurrency.h"
 
 #include <cassert>
@@ -436,6 +437,37 @@ namespace detail {
   };
 }
 
+/// Diagnose any non-Sendable types that occur within the given type, using
+/// the given diagnostic.
+///
+/// \returns \c true if any errors were produced, \c false if no diagnostics or
+/// only warnings and notes were produced or if a decl contains a sending
+/// parameter or result
+template <typename... DiagArgs>
+bool diagnoseNonSendableTypesWithSendingCheck(
+    ValueDecl *decl, Type type, SendableCheckContext fromContext,
+    Type derivedConformance, SourceLoc typeLoc, SourceLoc diagnoseLoc,
+    Diag<Type, DiagArgs...> diag,
+    typename detail::Identity<DiagArgs>::type... diagArgs) {
+  if (auto param = dyn_cast<ParamDecl>(decl)) {
+    if (param->isSending()) {
+      return false;
+    }
+  }
+  if (auto *func = dyn_cast<FuncDecl>(decl)) {
+    if (func->hasSendingResult())
+      return false;
+  }
+  if (auto *subscript = dyn_cast<SubscriptDecl>(decl)) {
+    if (isa<SendingTypeRepr>(subscript->getResultTypeRepr()))
+      return false;
+  }
+
+  return diagnoseNonSendableTypes(
+      type, fromContext, derivedConformance, typeLoc, diagnoseLoc, diag,
+      std::forward<decltype(diagArgs)>(diagArgs)...);
+}
+
 /// Diagnose any non-Sendable types that occur within the given type, using
 /// the given diagnostic.
 ///