[sending] Make it so that we suppress fields of Nominal Types in API notes.

rdar://129045783

Author: gottesmm

lib/AST/FeatureSet.cpp

@@ -647,8 +647,7 @@ UNINTERESTING_FEATURE(GroupActorErrors)
 
 UNINTERESTING_FEATURE(TransferringArgsAndResults)
 static bool usesFeatureSendingArgsAndResults(Decl *decl) {
-  auto functionTypeUsesSending = [](Decl *decl) {
-    return usesTypeMatching(decl, [](Type type) {
+  auto isFunctionTypeWithSending = [](Type type) {
       auto fnType = type->getAs<AnyFunctionType>();
       if (!fnType)
         return false;
@@ -660,15 +659,17 @@ static bool usesFeatureSendingArgsAndResults(Decl *decl) {
                           [](AnyFunctionType::Param param) {
                             return param.getParameterFlags().isSending();
                           });
-    });
+  };
+  auto declUsesFunctionTypesThatUseSending = [&](Decl *decl) {
+    return usesTypeMatching(decl, isFunctionTypeWithSending);
   };
 
   if (auto *pd = dyn_cast<ParamDecl>(decl)) {
     if (pd->isSending()) {
       return true;
     }
 
-    if (functionTypeUsesSending(pd))
+    if (declUsesFunctionTypesThatUseSending(pd))
       return true;
   }
 
@@ -678,10 +679,20 @@ static bool usesFeatureSendingArgsAndResults(Decl *decl) {
           return usesFeatureSendingArgsAndResults(pd);
         }))
       return true;
-    if (functionTypeUsesSending(decl))
+    if (declUsesFunctionTypesThatUseSending(decl))
       return true;
   }
 
+  // Check if we have a pattern binding decl for a function that has sending
+  // parameters and results.
+  if (auto *pbd = dyn_cast<PatternBindingDecl>(decl)) {
+    for (auto index : range(pbd->getNumPatternEntries())) {
+      auto *pattern = pbd->getPattern(index);
+      if (pattern->hasType() && isFunctionTypeWithSending(pattern->getType()))
+        return true;
+    }
+  }
+
   return false;
 }
 

test/Concurrency/sending_conditional_suppression.swift

@@ -153,6 +153,40 @@ public struct TestInStruct {
   // CHECK-NEXT: #endif
   @usableFromInline
   func testUsableFromInlineFunctionResult() -> (() -> sending NonSendableKlass) { fatalError() }
+
+  // CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults
+  // CHECK-NEXT: public var publicVarFieldFunctionArg: (sending test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: public var publicVarFieldFunctionArg: (test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #endif
+  public var publicVarFieldFunctionArg: (sending NonSendableKlass) -> ()
+
+  // CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults
+  // CHECK-NEXT: @usableFromInline
+  // CHECK-NEXT: internal var internalVarFieldFunctionArg: (sending test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: @usableFromInline
+  // CHECK-NEXT: internal var internalVarFieldFunctionArg: (test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #endif
+  @usableFromInline
+  var internalVarFieldFunctionArg: (sending NonSendableKlass) -> ()
+
+  // CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults
+  // CHECK-NEXT: public let publicLetFieldFunctionArg: (sending test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: public let publicLetFieldFunctionArg: (test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #endif
+  public let publicLetFieldFunctionArg: (sending NonSendableKlass) -> ()
+
+  // CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults
+  // CHECK-NEXT: @usableFromInline
+  // CHECK-NEXT: internal let internalLetFieldFunctionArg: (sending test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: @usableFromInline
+  // CHECK-NEXT: internal let internalLetFieldFunctionArg: (test.NonSendableKlass) -> ()
+  // CHECK-NEXT: #endif
+  @usableFromInline
+  let internalLetFieldFunctionArg: (sending NonSendableKlass) -> ()
 }
 
 // Make sure that we emit compiler(>= 5.3) when emitting the suppressing check