Use generic signature instead of ASTContext to warn about sending on Sendable type

Follow PR review comments and extend the warnings about sending on sendable types to cover types with a type parameter, and use generic signature instead of ASTContext to check conformance to Sendable. Additionally, use different warning messages based on whether the sending on Sendable is used on a function parameter or function result.

Author: Androp0v

include/swift/AST/DiagnosticsSema.def

@@ -7952,9 +7952,12 @@ ERROR(sending_unsupported_param_specifier, none,
       "'%0' cannot be applied to a 'sending' parameter", (StringRef))
 ERROR(sending_only_on_parameters_and_results, none,
       "'sending' may only be used on parameters and results", ())
-WARNING(sending_applied_to_sendable, none,
+WARNING(sending_applied_to_sendable_parameter, none,
         "'sending' has no effect on Sendable parameter %0",
         (Type))
+WARNING(sending_applied_to_sendable_result, none,
+        "'sending' has no effect on Sendable function result type %0",
+        (Type))
 ERROR(sending_cannot_be_applied_to_tuple_elt, none,
       "'sending' cannot be applied to tuple elements", ())
 ERROR(sending_function_wrong_sending,none,

lib/Sema/TypeCheckType.cpp

@@ -4977,23 +4977,22 @@ TypeResolver::resolveSendingTypeRepr(SendingTypeRepr *repr,
   }
 
   NeverNullType resolvedType = resolveType(repr->getBase(), options);
-  
+
   // If resolved type is Sendable, warn about unnecessary 'sending' annotation.
-  if (options.is(TypeResolverContext::FunctionInput)) {
-    if(!resolvedType->hasTypeParameter()) {
-      if (resolvedType->isSendableType()) {
-        diagnose(repr->getSpecifierLoc(),
-                 diag::sending_applied_to_sendable,
-                 resolvedType.get())
-        .fixItRemove(repr->getSpecifierLoc());
-      }
-    } else {
-      if (resolvedType->getASTContext().getProtocol(KnownProtocolKind::Sendable)) {
-        diagnose(repr->getSpecifierLoc(),
-                 diag::sending_applied_to_sendable,
-                 resolvedType.get())
-        .fixItRemove(repr->getSpecifierLoc());
-      };
+  bool isFunctionParam = options.is(TypeResolverContext::FunctionInput);
+  bool isFunctionResult = options.is(TypeResolverContext::FunctionResult);
+  if (inStage(TypeResolutionStage::Interface) 
+      && (isFunctionParam || isFunctionResult)) {
+    auto contextTy = GenericEnvironment::mapTypeIntoContext(
+        resolution.getGenericSignature().getGenericEnvironment(), 
+        resolvedType);
+    if (contextTy->isSendableType()) {
+      diagnose(repr->getSpecifierLoc(),
+               isFunctionParam
+                 ? diag::sending_applied_to_sendable_parameter
+                 : diag::sending_applied_to_sendable_result,
+               resolvedType.get())
+      .fixItRemove(repr->getSpecifierLoc());
     }
   }
 

test/type/function/sending_sendable_parameter.swift

@@ -1,20 +1,32 @@
 // RUN: %target-swift-frontend -module-name TestModule -typecheck -verify %s
 
 struct SendableType {}
-class NonSendableType {}
+class NonSendableType {
+    init() {}
+}
+struct SendableTypeWithTypeParam<SendableType> {}
 
-func testSendingOnNonSendable(input: sending NonSendableType) {
-    // okay
+func testSendingOnNonSendable(input: sending NonSendableType) -> sending NonSendableType {
+    return NonSendableType() // okay
 }
 
-func testSendingOnSendable(input: sending SendableType) {
-    // expected-warning@-1{{'sending' has no effect}}{{35-43=}}
+func testSendingOnSendableParam(input: sending SendableType) {
+    // expected-warning@-1{{'sending' has no effect}}{{40-48=}}
 }
 
-func testSendingOnSendable(input: sending some Sendable) {
+func testSendingOnSendable(input: sending SendableTypeWithTypeParam<SendableType>) {
     // expected-warning@-1{{'sending' has no effect}}{{35-43=}}
 }
 
-func testSendingOnSendable(input: sending any Sendable) {
-    // expected-warning@-1{{'sending' has no effect}}{{35-43=}}
-}
+func testSendingOnSendableParam(input: sending some Sendable) {
+    // expected-warning@-1{{'sending' has no effect}}{{40-48=}}
+}
+
+func testSendingOnSendableParam(input: sending any Sendable) {
+    // expected-warning@-1{{'sending' has no effect}}{{40-48=}}
+}
+
+func testSendingOnSendableResult() -> sending SendableType {
+    // expected-warning@-1{{'sending' has no effect}}{{39-47=}}
+    return SendableType()
+}