TypeCheckType: Do not emit migration mode diags if nonisolated(nonsending) is explicit

This broke when we split `@execution(...)` into `@concurrent` and
`nonisolated(nonsending)` because the latter became its own `TypeRepr`,
whereas the condition for whether to attempt migration diagnostics
inside `resolveASTFunctionType` is still based on the function type's
attributes alone.

(cherry picked from commit bee2b67)

Author: AnthonyLatsis

lib/Sema/TypeCheckType.cpp

@@ -2418,6 +2418,11 @@ namespace {
   class TypeAttrSet {
     const ASTContext &ctx;
 
+    /// FIXME:
+    ///  `nonisolated(nonsending)` is modeled as a separate `TypeRepr`, but
+    ///  needs to be considered together with subsequent attributes.
+    CallerIsolatedTypeRepr *nonisolatedNonsendingAttr;
+
     llvm::TinyPtrVector<CustomAttr*> customAttrs;
     EnumMap<TypeAttrKind, TypeAttribute *> typeAttrs;
 
@@ -2429,7 +2434,9 @@ namespace {
 #endif
 
   public:
-    TypeAttrSet(const ASTContext &ctx) : ctx(ctx) {}
+    TypeAttrSet(const ASTContext &ctx,
+                CallerIsolatedTypeRepr *nonisolatedNonsendingAttr = nullptr)
+        : ctx(ctx), nonisolatedNonsendingAttr(nonisolatedNonsendingAttr) {}
 
     TypeAttrSet(const TypeAttrSet &) = delete;
     TypeAttrSet &operator=(const TypeAttrSet &) = delete;
@@ -2448,6 +2455,10 @@ namespace {
     /// will be diagnosed.
     void accumulate(ArrayRef<TypeOrCustomAttr> attrs);
 
+    CallerIsolatedTypeRepr *getNonisolatedNonsendingAttr() const {
+      return nonisolatedNonsendingAttr;
+    }
+
     /// Return all of the custom attributes.
     ArrayRef<CustomAttr*> getCustomAttrs() const {
       return customAttrs;
@@ -2547,9 +2558,17 @@ namespace {
   }
 
   template <class AttrClass>
-  AttrClass *getWithoutClaiming(TypeAttrSet *attrs) {
+  std::enable_if_t<std::is_base_of_v<TypeAttribute, AttrClass>, AttrClass *>
+  getWithoutClaiming(TypeAttrSet *attrs) {
     return (attrs ? getWithoutClaiming<AttrClass>(*attrs) : nullptr);
   }
+
+  template <class AttrClass>
+  std::enable_if_t<std::is_same_v<AttrClass, CallerIsolatedTypeRepr>,
+                   CallerIsolatedTypeRepr *>
+  getWithoutClaiming(TypeAttrSet *attrs) {
+    return attrs ? attrs->getNonisolatedNonsendingAttr() : nullptr;
+  }
 } // end anonymous namespace
 
 Type TypeResolution::resolveContextualType(
@@ -4247,10 +4266,19 @@ NeverNullType TypeResolver::resolveASTFunctionType(
   };
 
   if (auto concurrentAttr = claim<ConcurrentTypeAttr>(attrs)) {
+    if (auto *nonisolatedNonsendingAttr =
+            getWithoutClaiming<CallerIsolatedTypeRepr>(attrs)) {
+      diagnoseInvalid(
+          nonisolatedNonsendingAttr, nonisolatedNonsendingAttr->getStartLoc(),
+          diag::cannot_use_nonisolated_nonsending_together_with_concurrent,
+          nonisolatedNonsendingAttr);
+    }
+
     checkExecutionBehaviorAttribute(concurrentAttr);
+
     if (!repr->isInvalid())
       isolation = FunctionTypeIsolation::forNonIsolated();
-  } else {
+  } else if (!getWithoutClaiming<CallerIsolatedTypeRepr>(attrs)) {
     if (ctx.LangOpts.getFeatureState(Feature::NonisolatedNonsendingByDefault)
             .isEnabledForMigration()) {
       // Diagnose only in the interface stage, which is run once.
@@ -5281,7 +5309,20 @@ TypeResolver::resolveSendingTypeRepr(SendingTypeRepr *repr,
 NeverNullType
 TypeResolver::resolveCallerIsolatedTypeRepr(CallerIsolatedTypeRepr *repr,
                                             TypeResolutionOptions options) {
-  Type type = resolveType(repr->getBase(), options);
+  Type type;
+  {
+    TypeAttrSet attrs(getASTContext(), repr);
+
+    auto *baseRepr = repr->getBase();
+    if (auto *attrRepr = dyn_cast<AttributedTypeRepr>(baseRepr)) {
+      baseRepr = attrs.accumulate(attrRepr);
+    }
+
+    type = resolveAttributedType(baseRepr, options, attrs);
+
+    attrs.diagnoseUnclaimed(resolution, options, type);
+  }
+
   if (type->hasError())
     return ErrorType::get(getASTContext());
 
@@ -5297,15 +5338,6 @@ TypeResolver::resolveCallerIsolatedTypeRepr(CallerIsolatedTypeRepr *repr,
                     diag::nonisolated_nonsending_only_on_async, repr);
   }
 
-  if (auto *ATR = dyn_cast<AttributedTypeRepr>(repr->getBase())) {
-    if (ATR->get(TypeAttrKind::Concurrent)) {
-      diagnoseInvalid(
-          repr, repr->getStartLoc(),
-          diag::cannot_use_nonisolated_nonsending_together_with_concurrent,
-          repr);
-    }
-  }
-
   switch (fnType->getIsolation().getKind()) {
   case FunctionTypeIsolation::Kind::NonIsolated:
     break;

test/Concurrency/attr_execution/adoption_mode.swift

@@ -12,8 +12,8 @@ struct G<T> {
 // MARK: Functions
 do {
   func syncF() {}
-  @concurrent func executionConcurrentAsyncF() async {}
-  nonisolated(nonsending) func executionCallerAsyncF() async {}
+  @concurrent func concurrentAsyncF() async {}
+  nonisolated(nonsending) func nonisolatedNonsendingAsyncF() async {}
   @MainActor func mainActorAsyncF() async {}
   func isolatedParamAsyncF(
     isolation: isolated (any Actor)? = #isolation
@@ -24,13 +24,15 @@ do {
 
   struct S {
     init(sync: ()) {}
-    @concurrent init(executionAsync: ()) async {}
+    @concurrent init(concurrentAsync: ()) async {}
+    nonisolated(nonsending) init(nonisolatedNonsendingAsync: ()) async {}
     @MainActor init(mainActorAsync: ()) async {}
     // expected-warning@+1:5 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async initializer 'init' to run on the caller's actor; use @concurrent to preserve behavior}}{{5-5=@concurrent }}{{none}}
     init(async: ()) async {}
 
     func syncF() {}
-    @concurrent func executionAsyncF() async {}
+    @concurrent func concurrentAsyncF() async {}
+    nonisolated(nonsending) func nonisolatedNonsendingAsyncF() async {}
     @MainActor func mainActorAsyncF() async {}
     // expected-warning@+2:17 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async instance method 'asyncF' to run on the caller's actor; use @concurrent to preserve behavior}}{{-1:5-5=@concurrent }}{{none}}
     nonisolated
@@ -39,13 +41,15 @@ do {
 
   protocol P {
     init(sync: ())
-    @concurrent init(executionAsync: ()) async
+    @concurrent init(concurrentAsync: ()) async
+    nonisolated(nonsending) init(nonisolatedNonsendingAsync: ()) async
     @MainActor init(mainActorAsync: ()) async
     // expected-warning@+1:5 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async initializer 'init' to run on the caller's actor; use @concurrent to preserve behavior}}{{5-5=@concurrent }}{{none}}
     init(async: ()) async
 
     func syncF()
-    @concurrent func executionAsyncF() async
+    @concurrent func concurrentAsyncF() async
+    nonisolated(nonsending) func nonisolatedNonsendingAsyncF() async
     @MainActor func mainActorAsyncF() async
     // expected-warning@+1:10 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async instance method 'asyncF' to run on the caller's actor; use @concurrent to preserve behavior}}{{5-5=@concurrent }}{{none}}
     func asyncF() async
@@ -54,13 +58,15 @@ do {
 protocol Functions {}
 extension Functions {
   init(sync: ()) {}
-  @concurrent init(executionAsync: ()) async {}
+  @concurrent init(concurrentAsync: ()) async {}
+  nonisolated(nonsending) init(nonisolatedNonsendingAsync: ()) async {}
   @MainActor init(mainActorAsync: ()) async {}
   // expected-warning@+1:3 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async initializer 'init' to run on the caller's actor; use @concurrent to preserve behavior}}{{3-3=@concurrent }}{{none}}
   init(async: ()) async {}
 
   func syncF() {}
-  @concurrent func executionAsyncF() async {}
+  @concurrent func concurrentAsyncF() async {}
+  nonisolated(nonsending) func nonisolatedNonsendingAsyncF() async {}
   @MainActor func mainActorAsyncF() async {}
   // expected-warning@+1:8 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async instance method 'asyncF' to run on the caller's actor; use @concurrent to preserve behavior}}{{3-3=@concurrent }}{{none}}
   func asyncF() async {}
@@ -75,8 +81,11 @@ do {
     var syncS: Int { get {} set {} }
     subscript(syncS _: Int) -> Int { get {} }
 
-    @concurrent var executionAsyncS: Int { get async {} }
-    @concurrent subscript(executionAsyncS _: Int) -> Int { get async {} }
+    @concurrent var concurrentAsyncS: Int { get async {} }
+    @concurrent subscript(concurrentAsyncS _: Int) -> Int { get async {} }
+
+    nonisolated(nonsending) var nonisolatedNonsendingAsyncS: Int { get async {} }
+    nonisolated(nonsending) subscript(nonisolatedNonsendingAsyncS _: Int) -> Int { get async {} }
 
     @MainActor var mainActorAsyncS: Int { get async {} }
     @MainActor subscript(mainActorAsyncS _: Int) -> Int { get async {} }
@@ -95,8 +104,11 @@ do {
     var syncS: Int { get }
     subscript(syncS _: Int) -> Int { get }
 
-    @concurrent var executionAsyncS: Int { get async }
-    @concurrent subscript(executionAsyncS _: Int) -> Int { get async }
+    @concurrent var concurrentAsyncS: Int { get async }
+    @concurrent subscript(concurrentAsyncS _: Int) -> Int { get async }
+
+    nonisolated(nonsending) var nonisolatedNonsendingAsyncS: Int { get async }
+    nonisolated(nonsending) subscript(nonisolatedNonsendingAsyncS _: Int) -> Int { get async }
 
     @MainActor var mainActorAsyncS: Int { get async }
     @MainActor subscript(mainActorAsyncS _: Int) -> Int { get async }
@@ -112,8 +124,11 @@ extension Storage {
   var syncS: Int { get {} set {} }
   subscript(syncS _: Int) -> Int { get {} }
 
-  @concurrent var executionAsyncS: Int { get async {} }
-  @concurrent subscript(executionAsyncS _: Int) -> Int { get async {} }
+  @concurrent var concurrentAsyncS: Int { get async {} }
+  @concurrent subscript(concurrentAsyncS _: Int) -> Int { get async {} }
+
+  nonisolated(nonsending) var nonisolatedNonsendingAsyncS: Int { get async {} }
+  nonisolated(nonsending) subscript(nonisolatedNonsendingAsyncS _: Int) -> Int { get async {} }
 
   @MainActor var mainActorAsyncS: Int { get async {} }
   @MainActor subscript(mainActorAsyncS _: Int) -> Int { get async {} }
@@ -134,7 +149,8 @@ do {
   enum E {
     case esac(
       sync: () -> Void,
-      executionAsync: @concurrent () async -> Void,
+      concurrentAsync: @concurrent () async -> Void,
+      nonisolatedNonsendingAsync: nonisolated(nonsending) () async -> Void,
       mainActorAsync: @MainActor () async -> Void,
       // expected-warning@+1:14 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{14-14=@concurrent }}{{none}}
       async: () async -> Void,
@@ -146,7 +162,8 @@ do {
   struct S {
     subscript(
       sync: () -> Void,
-      executionAsync: @concurrent () async -> Void,
+      concurrentAsync: @concurrent () async -> Void,
+      nonisolatedNonsendingAsync: nonisolated(nonsending) () async -> Void,
       mainActorAsync: @MainActor () async -> Void,
       // expected-warning@+1:14 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{14-14=@concurrent }}{{none}}
       async: () async -> Void,
@@ -159,7 +176,8 @@ do {
 
   func foo(
     sync: () -> Void,
-    executionAsync: @concurrent () async -> Void,
+    concurrentAsync: @concurrent () async -> Void,
+    nonisolatedNonsendingAsync: nonisolated(nonsending) () async -> Void,
     mainActorAsync: @MainActor () async -> Void,
     // expected-warning@+1:12 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{12-12=@concurrent }}{{none}}
     async: () async -> Void,
@@ -169,7 +187,8 @@ do {
 
   let _ = { (
     sync: () -> Void,
-    executionAsync: @concurrent () async -> Void,
+    concurrentAsync: @concurrent () async -> Void,
+    nonisolatedNonsendingAsync: nonisolated(nonsending) () async -> Void,
     mainActorAsync: @MainActor () async -> Void,
     // expected-warning@+1:12 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{12-12=@concurrent }}{{none}}
     async: () async -> Void,
@@ -183,7 +202,8 @@ do {
 do {
   struct G<T> {
     struct Sync where T == () -> Void {}
-    struct ExecutionAsync where T == @concurrent () async -> Void {}
+    struct ConcurrentAsync where T == @concurrent () async -> Void {}
+    struct NonisolatedNonsendingAsync where T == nonisolated(nonsending) () async -> Void {}
     struct MainActorAsync where T == @MainActor () async -> Void {}
     // expected-warning@+1:29 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{29-29=@concurrent }}{{none}}
     struct Async where T == () async -> Void {}
@@ -196,6 +216,7 @@ do {
 do {
   let _: () -> Void
   let _: @concurrent () async -> Void
+  let _: nonisolated(nonsending) () async -> Void
   let _: @MainActor () async -> Void
   // expected-warning@+1:10 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{10-10=@concurrent }}{{none}}
   let _: () async -> Void
@@ -209,6 +230,7 @@ do {
 
   let _ = anything as? () -> Void
   let _ = anything as? @concurrent () async -> Void
+  let _ = anything as? nonisolated(nonsending) () async -> Void
   let _ = anything as? @MainActor () async -> Void
   // expected-warning@+1:24 {{feature 'NonisolatedNonsendingByDefault' will cause nonisolated async function type to be treated as specified to run on the caller's actor; use @concurrent to preserve behavior}}{{24-24=@concurrent }}{{none}}
   let _ = anything as? () async -> Void