Frontend: Enable $GlobalActors feature by default.

Global actors have been an accepted language feature for a couple of compiler releases now, but the feature definition was associated with the `--enable-experimental-concurrency` flag. This caused some `.swiftinterface`s containing global actor declarations to be unparsable because the logic for surrounding declarations with the `$GlobalActors` feature guard was incomplete (for example, classes with a global actor attribute were not guarded even though the declarations of global actor types were).

Rather than trying to fix the logic of `usesFeatureGlobalActors()`, enable it by default.

Adds a test that demonstrates that modules defining and using public global actors produce module interfaces that can be parsed successfully.

Resolves rdar://100150703

Author: tshortli

include/swift/Basic/Features.def

@@ -67,7 +67,7 @@ LANGUAGE_FEATURE(Actors, 0, "actors", true)
 LANGUAGE_FEATURE(Actors2, 0, "actors #2 (TEMPORARY)", true)
 LANGUAGE_FEATURE(ConcurrentFunctions, 0, "@concurrent functions", true)
 LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol", true)
-LANGUAGE_FEATURE(GlobalActors, 0, "Global actors", langOpts.EnableExperimentalConcurrency)
+LANGUAGE_FEATURE(GlobalActors, 316, "Global actors", true)
 LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type", true)
 LANGUAGE_FEATURE(Sendable, 0, "Sendable and @Sendable", true)
 LANGUAGE_FEATURE(BuiltinExecutor, 0, "Builtin.Executor type", true)

lib/AST/ASTPrinter.cpp

@@ -2844,17 +2844,6 @@ static bool usesFeatureRethrowsProtocol(Decl *decl) {
 }
 
 static bool usesFeatureGlobalActors(Decl *decl) {
-  if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
-    if (nominal->getAttrs().hasAttribute<GlobalActorAttr>())
-      return true;
-  }
-
-  if (auto ext = dyn_cast<ExtensionDecl>(decl)) {
-    if (auto nominal = ext->getExtendedNominal())
-      if (usesFeatureGlobalActors(nominal))
-        return true;
-  }
-
   return false;
 }
 

test/ModuleInterface/features.swift

@@ -125,13 +125,6 @@ extension Array: FeatureTest.MP where Element : FeatureTest.MP { }
 extension OldSchool: UnsafeSendable { }
 // CHECK-NEXT: }
 
-// CHECK: #if compiler(>=5.3) && $GlobalActors
-// CHECK-NEXT: @globalActor public struct SomeGlobalActor
-@globalActor
-public struct SomeGlobalActor {
-  public static let shared = MyActor()
-}
-
 
 // CHECK: #if compiler(>=5.3) && $AsyncAwait
 // CHECK-NEXT: func runSomethingSomewhere
@@ -196,7 +189,3 @@ public func unavailableFromAsyncFunc() { }
 public func noAsyncFunc() { }
 
 // CHECK-NOT: extension FeatureTest.MyActor : Swift.Sendable
-
-// CHECK: #if compiler(>=5.3) && $GlobalActors
-// CHECK-NEXT: extension FeatureTest.SomeGlobalActor : _Concurrency.GlobalActor {}
-// CHECK-NEXT: #endif

test/ModuleInterface/global-actor.swift

@@ -0,0 +1,49 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-emit-module-interface(%t.swiftinterface) %s -module-name Test
+// RUN: %target-swift-typecheck-module-from-interface(%t.swiftinterface) -module-name Test
+// RUN: %FileCheck %s < %t.swiftinterface
+
+// REQUIRES: concurrency
+
+// Global actors are no longer protected with a feature guard.
+// CHECK-NOT: $GlobalActors
+
+// CHECK: @globalActor public struct GlobalActor {
+@globalActor public struct GlobalActor {
+  public actor Actor { }
+  public static let shared = Actor()
+}
+
+// CHECK: @Test.GlobalActor public func funcBoundToGlobalActor()
+@GlobalActor public func funcBoundToGlobalActor() { }
+
+// CHECK: public func funcWithParameterBoundToGlobalActor(_ x: Test.ClassBoundToGlobalActor)
+public func funcWithParameterBoundToGlobalActor(_ x: ClassBoundToGlobalActor) { }
+
+// CHECK: @_hasMissingDesignatedInitializers @Test.GlobalActor public class ClassBoundToGlobalActor
+@GlobalActor public class ClassBoundToGlobalActor { }
+
+// CHECK: extension Test.ClassBoundToGlobalActor
+extension ClassBoundToGlobalActor {
+  public func someMethod() { }
+}
+
+// CHECK: @_inheritsConvenienceInitializers @_hasMissingDesignatedInitializers @Test.GlobalActor public class DerivedFromClassBoundToGlobalActor : Test.ClassBoundToGlobalActor
+public class DerivedFromClassBoundToGlobalActor: ClassBoundToGlobalActor {}
+
+// CHECK: public class NoActorClass
+public class NoActorClass {
+  // CHECK: @Test.GlobalActor public var varBoundToGlobalActor: Swift.Int
+  @GlobalActor public var varBoundToGlobalActor: Int
+  
+  // CHECK: @Test.GlobalActor public init()
+  @GlobalActor public init() {
+    self.varBoundToGlobalActor = 0
+  }
+
+  // CHECK: @Test.GlobalActor public func methodBoundToGlobalActor()
+  @GlobalActor public func methodBoundToGlobalActor() { }
+}
+
+// CHECK: extension Test.GlobalActor : _Concurrency.GlobalActor {}
+// CHECK: extension Test.ClassBoundToGlobalActor : Swift.Sendable {}