Revert "[Concurrency] Prevent use of nonisolated(nonsending) and @concurrent on @_inheritActorContext parameters"

This reverts commit e032f33.

Author: gottesmm

include/swift/AST/DiagnosticsSema.def

@@ -8706,14 +8706,6 @@ ERROR(inherit_actor_context_only_on_async_or_isolation_erased_params,none,
       "asynchronous function types",
       (DeclAttribute))
 
-ERROR(inherit_actor_context_with_concurrent,none,
-      "'@_inheritActorContext' attribute cannot be used together with %0",
-      (const TypeAttribute *))
-
-ERROR(inherit_actor_context_with_nonisolated_nonsending,none,
-      "'@_inheritActorContext' attribute cannot be used together with %0",
-      (TypeRepr *))
-
 //===----------------------------------------------------------------------===//
 // MARK: @concurrent and nonisolated(nonsending) attributes
 //===----------------------------------------------------------------------===//

lib/Sema/TypeCheckAttr.cpp

@@ -7864,9 +7864,6 @@ void AttributeChecker::visitInheritActorContextAttr(
     return;
 
   auto paramTy = P->getInterfaceType();
-  if (paramTy->hasError())
-    return;
-
   auto *funcTy =
       paramTy->lookThroughAllOptionalTypes()->getAs<AnyFunctionType>();
   if (!funcTy) {

lib/Sema/TypeCheckDecl.cpp

@@ -2337,9 +2337,6 @@ static Type validateParameterType(ParamDecl *decl) {
   if (dc->isInSpecializeExtensionContext())
     options |= TypeResolutionFlags::AllowUsableFromInline;
 
-  if (decl->getAttrs().hasAttribute<InheritActorContextAttr>())
-    options |= TypeResolutionFlags::InheritsActorContext;
-
   Type Ty;
 
   auto *nestedRepr = decl->getTypeRepr();

lib/Sema/TypeCheckType.cpp

@@ -4219,11 +4219,6 @@ NeverNullType TypeResolver::resolveASTFunctionType(
                       attr->getAttrName());
     }
 
-    if (options.contains(TypeResolutionFlags::InheritsActorContext)) {
-      diagnoseInvalid(repr, attr->getAttrLoc(),
-                      diag::inherit_actor_context_with_concurrent, attr);
-    }
-
     switch (isolation.getKind()) {
     case FunctionTypeIsolation::Kind::NonIsolated:
       break;
@@ -4270,20 +4265,18 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     if (!repr->isInvalid())
       isolation = FunctionTypeIsolation::forNonIsolated();
   } else if (!getWithoutClaiming<CallerIsolatedTypeRepr>(attrs)) {
-    if (!options.contains(TypeResolutionFlags::InheritsActorContext)) {
-      // Infer async function type as `nonisolated(nonsending)` if there is
-      // no `@concurrent` or `nonisolated(nonsending)` attribute and isolation
-      // is nonisolated.
-      if (ctx.LangOpts.hasFeature(Feature::NonisolatedNonsendingByDefault) &&
-          repr->isAsync() && isolation.isNonIsolated()) {
-        isolation = FunctionTypeIsolation::forNonIsolatedCaller();
-      } else if (ctx.LangOpts
-                     .getFeatureState(Feature::NonisolatedNonsendingByDefault)
-                     .isEnabledForMigration()) {
-        // Diagnose only in the interface stage, which is run once.
-        if (inStage(TypeResolutionStage::Interface)) {
-          warnAboutNewNonisolatedAsyncExecutionBehavior(ctx, repr, isolation);
-        }
+    // Infer async function type as `nonisolated(nonsending)` if there is
+    // no `@concurrent` or `nonisolated(nonsending)` attribute and isolation
+    // is nonisolated.
+    if (ctx.LangOpts.hasFeature(Feature::NonisolatedNonsendingByDefault) &&
+        repr->isAsync() && isolation.isNonIsolated()) {
+      isolation = FunctionTypeIsolation::forNonIsolatedCaller();
+    } else if (ctx.LangOpts
+                   .getFeatureState(Feature::NonisolatedNonsendingByDefault)
+                   .isEnabledForMigration()) {
+      // Diagnose only in the interface stage, which is run once.
+      if (inStage(TypeResolutionStage::Interface)) {
+        warnAboutNewNonisolatedAsyncExecutionBehavior(ctx, repr, isolation);
       }
     }
   }
@@ -5333,12 +5326,6 @@ TypeResolver::resolveCallerIsolatedTypeRepr(CallerIsolatedTypeRepr *repr,
     return ErrorType::get(getASTContext());
   }
 
-  if (options.contains(TypeResolutionFlags::InheritsActorContext)) {
-    diagnoseInvalid(repr, repr->getLoc(),
-                    diag::inherit_actor_context_with_nonisolated_nonsending,
-                    repr);
-  }
-
   if (!fnType->isAsync()) {
     diagnoseInvalid(repr, repr->getStartLoc(),
                     diag::nonisolated_nonsending_only_on_async, repr);

lib/Sema/TypeCheckType.h

@@ -87,9 +87,6 @@ enum class TypeResolutionFlags : uint16_t {
 
   /// Whether the immediate context has an @escaping attribute.
   DirectEscaping = 1 << 14,
-
-  /// We are in a `@_inheritActorContext` parameter declaration.
-  InheritsActorContext = 1 << 15,
 };
 
 /// Type resolution contexts that require special handling.

test/Concurrency/attr_execution/attr_execution.swift

@@ -80,16 +80,3 @@ func testClosure() {
   takesClosure {
   }
 }
-
-// CHECK-LABEL: // testInheritsActor(fn:)
-// CHECK: Isolation: global_actor. type: MainActor
-// CHECK: sil hidden [ossa] @$s14attr_execution17testInheritsActor2fnyyyYaYbXE_tYaF : $@convention(thin) @async (@guaranteed @noescape @Sendable @async @callee_guaranteed () -> ()) -> ()
-// CHECK: bb0([[FN:%.*]] : @guaranteed $@noescape @Sendable @async @callee_guaranteed () -> ()):
-// CHECK:  [[FN_COPY:%.*]] = copy_value [[FN]]
-// CHECK:  [[BORROWED_FN_COPY:%.*]] = begin_borrow [[FN_COPY]]
-// CHECK:  apply [[BORROWED_FN_COPY]]() : $@noescape @Sendable @async @callee_guaranteed () -> ()
-// CHECK: } // end sil function '$s14attr_execution17testInheritsActor2fnyyyYaYbXE_tYaF'
-@MainActor
-func testInheritsActor(@_inheritActorContext(always) fn: @Sendable () async -> Void) async {
-  await fn()
-}

test/Concurrency/attr_execution/migration_mode.swift

@@ -393,9 +393,3 @@ do {
     }
   }
 }
-
-// @_inheritActorContext prevents `nonisolated(nonsending)` inference.
-do {
-  func testInherit1(@_inheritActorContext _: @Sendable () async -> Void) {}
-  func testInherit2(@_inheritActorContext(always) _: (@Sendable () async -> Void)?) {}
-}

test/Concurrency/attr_execution/nonisolated_nonsending_by_default.swift

@@ -8,8 +8,3 @@ func testCasts() {
   // expected-error@-1 {{cannot convert value of type '(nonisolated(nonsending) () async -> ()).Type' to type '(() async -> ()).Type' in coercion}}
   _ = defaultedType as (nonisolated(nonsending) () async -> ()).Type // Ok
 }
-
-func test(@_inheritActorContext fn: @Sendable () async -> Void) {
-  let _: Int = fn
-  // expected-error@-1 {{cannot convert value of type '@Sendable () async -> Void' to specified type 'Int'}}
-}

test/Parse/execution_behavior_attrs.swift

@@ -84,10 +84,3 @@ do {
   nonisolated(0) // expected-warning {{result of call to 'nonisolated' is unused}}
   print("hello")
 }
-
-do {
-  func testActorInheriting1(@_inheritActorContext _: @concurrent @Sendable () async -> Void) {}
-  // expected-error@-1 {{'@_inheritActorContext' attribute cannot be used together with '@concurrent'}}
-  func testActorInheriting2(@_inheritActorContext _: nonisolated(nonsending) @Sendable () async -> Void) {}
-  // expected-error@-1 {{'@_inheritActorContext' attribute cannot be used together with 'nonisolated(nonsending)'}}
-}