[Sema]Skip Sendable conformance check when sending are added to parameters or return types of an actor-isolated function

Author: stzn

lib/Sema/TypeCheckConcurrency.cpp

@@ -1160,34 +1160,59 @@ bool swift::diagnoseNonSendableTypesInReference(
       return true;
   }
 
-  // For functions, check the parameter and result types.
+  // For functions or subscripts, check the parameter and result types.
   SubstitutionMap subs = declRef.getSubstitutions();
-  if (auto function = dyn_cast<AbstractFunctionDecl>(declRef.getDecl())) {
+  auto decl = declRef.getDecl();
+  if (isa<AbstractFunctionDecl>(decl) || isa<SubscriptDecl>(decl)) {
     if (funcCheckOptions.contains(FunctionCheckKind::Params)) {
       // only check params if funcCheckKind specifies so
-      for (auto param : *function->getParameters()) {
+      ParameterList *paramList = nullptr;
+      if (auto function = dyn_cast<AbstractFunctionDecl>(decl)) {
+        paramList = function->getParameters();
+      } else if (auto subscript = dyn_cast<SubscriptDecl>(decl)) {
+        paramList = subscript->getIndices();
+      }
+
+      // 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, diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
-                getSendableParamDiag(refKind),
-                function, getActorIsolation()))
+                                     paramType, fromDC, derivedConformanceType,
+                                     refLoc, diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
+                                     getSendableParamDiag(refKind),
+                                     decl, getActorIsolation()))
           return true;
       }
     }
 
-    // Check the result type of a function.
-    if (auto func = dyn_cast<FuncDecl>(function)) {
-      if (funcCheckOptions.contains(FunctionCheckKind::Results)) {
-        // only check results if funcCheckKind specifies so
-        Type resultType = func->getResultInterfaceType().subst(subs);
-        if (diagnoseNonSendableTypes(
-            resultType, fromDC, derivedConformanceType,
-            refLoc, diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
-            getSendableResultDiag(refKind),
-            func, getActorIsolation()))
-          return true;
+    // 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()))
+        return true;
     }
 
     return false;
@@ -1205,34 +1230,6 @@ bool swift::diagnoseNonSendableTypesInReference(
       return true;
   }
 
-  if (auto subscript = dyn_cast<SubscriptDecl>(declRef.getDecl())) {
-    for (auto param : *subscript->getIndices()) {
-      if (funcCheckOptions.contains(FunctionCheckKind::Params)) {
-        // Check params of this subscript override for sendability
-        Type paramType = param->getInterfaceType().subst(subs);
-        if (diagnoseNonSendableTypes(
-                paramType, fromDC, derivedConformanceType,
-                refLoc, diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
-                getSendableParamDiag(refKind),
-                subscript, getActorIsolation()))
-          return true;
-      }
-    }
-
-    if (funcCheckOptions.contains(FunctionCheckKind::Results)) {
-      // Check the element type of a subscript.
-      Type resultType = subscript->getElementInterfaceType().subst(subs);
-      if (diagnoseNonSendableTypes(
-              resultType, fromDC, derivedConformanceType,
-              refLoc, diagnoseLoc.isInvalid() ? refLoc : diagnoseLoc,
-              getSendableResultDiag(refKind),
-              subscript, getActorIsolation()))
-        return true;
-    }
-
-    return false;
-  }
-
   return false;
 }
 

test/Concurrency/sendable_conformance_checking_skip_sending.swift

@@ -0,0 +1,89 @@
+// RUN: %target-typecheck-verify-swift -swift-version 6
+
+// https://github.com/swiftlang/swift/issues/76710
+
+class NonSendableKlass1 {}
+
+protocol P1 {
+  func bar(_ a: sending NonSendableKlass1) async -> sending NonSendableKlass1
+}
+
+@MainActor
+class P1Class: P1 {
+  func bar(_ a: sending NonSendableKlass1) async -> sending NonSendableKlass1 { a }
+}
+
+class NonSendableKlass2 {}
+// expected-note@-1 2{{class 'NonSendableKlass2' does not conform to the 'Sendable' protocol}}
+
+protocol P2 {
+  func bar(_ a: NonSendableKlass2) async -> NonSendableKlass2
+}
+
+@MainActor
+class P2Class: P2 {
+  func bar(_ a: NonSendableKlass2) async -> NonSendableKlass2 { a }
+  // expected-error@-1 {{non-sendable type 'NonSendableKlass2' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'bar'}}
+  // expected-error@-2 {{non-sendable parameter type 'NonSendableKlass2' cannot be sent from caller of protocol requirement 'bar' into main actor-isolated implementation}}
+}
+
+class NonSendableKlass3 {}
+
+protocol P3 {
+  func bar(_ a: sending NonSendableKlass3) async -> sending NonSendableKlass3
+}
+
+actor P3Actor: P3 {
+  func bar(_ a: sending NonSendableKlass3) async -> sending NonSendableKlass3 { NonSendableKlass3() }
+}
+
+class NonSendableKlass4 {}
+// expected-note@-1 2{{class 'NonSendableKlass4' does not conform to the 'Sendable' protocol}}
+
+protocol P4 {
+  func bar(_ a: NonSendableKlass4) async -> NonSendableKlass4
+}
+
+actor P4Actor: P4 {
+  func bar(_ a: NonSendableKlass4) async -> NonSendableKlass4 { NonSendableKlass4() }
+  // expected-error@-1 {{non-sendable type 'NonSendableKlass4' cannot be returned from actor-isolated implementation to caller of protocol requirement 'bar'}}
+  // expected-error@-2 {{non-sendable parameter type 'NonSendableKlass4' cannot be sent from caller of protocol requirement 'bar' into actor-isolated implementation}}
+}
+
+class NonSendableKlass5 {}
+// expected-note@-1 {{class 'NonSendableKlass5' does not conform to the 'Sendable' protocol}}
+
+
+protocol P5 {
+  func bar(_ a: sending NonSendableKlass5, _ b: NonSendableKlass5) async -> sending NonSendableKlass5
+}
+
+@MainActor
+class P5Class: P5 {
+  func bar(_ a: sending NonSendableKlass5, _ b: NonSendableKlass5) async -> sending NonSendableKlass5 { a }
+  // expected-error@-1 {{non-sendable parameter type 'NonSendableKlass5' cannot be sent from caller of protocol requirement 'bar' into main actor-isolated implementation}}
+}
+
+class NonSendableKlass6 {}
+
+protocol P6 {
+  func bar(_ a: sending NonSendableKlass6, _ b: sending NonSendableKlass6) async -> sending NonSendableKlass6
+}
+
+@MainActor
+class P6Class: P6 {
+  func bar(_ a: sending NonSendableKlass6, _ b: sending NonSendableKlass6) async -> sending NonSendableKlass6 { a }
+}
+
+class NonSendableKlass7 {}
+
+protocol P7 {
+  subscript(_: sending NonSendableKlass7) -> sending NonSendableKlass7 { get async }
+}
+
+@MainActor
+struct S: P7 {
+  subscript(_: sending NonSendableKlass7) -> sending NonSendableKlass7 {
+    get async { NonSendableKlass7() }
+  }
+}