Sema: Relax availability checking for @MainActor.

The `@MainActor` global actor constraint on a declaration does not carry an
inherent ABI impact and therefore use of this constraint should not be limited
to OS versions where Swift concurrency is available.

Resolves rdar://105610970

Author: tshortli

include/swift/AST/ActorIsolation.h

@@ -160,6 +160,8 @@ class ActorIsolation {
     return getKind() == GlobalActor || getKind() == GlobalActorUnsafe;
   }
 
+  bool isMainActor() const;
+
   bool isDistributedActor() const;
 
   Type getGlobalActor() const {

include/swift/AST/Decl.h

@@ -3937,6 +3937,9 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Whether this nominal type qualifies as any actor (plain or distributed).
   bool isAnyActor() const;
 
+  /// Whether this nominal type is the `MainActor` global actor.
+  bool isMainActor() const;
+
   /// Return the range of semantics attributes attached to this NominalTypeDecl.
   auto getSemanticsAttrs() const
       -> decltype(getAttrs().getSemanticsAttrs()) {

lib/AST/Decl.cpp

@@ -4841,6 +4841,11 @@ bool NominalTypeDecl::isAnyActor() const {
   return isActor() || isDistributedActor();
 }
 
+bool NominalTypeDecl::isMainActor() const {
+  return getName().is("MainActor") &&
+         getParentModule()->getName() == getASTContext().Id_Concurrency;
+}
+
 GenericTypeDecl::GenericTypeDecl(DeclKind K, DeclContext *DC,
                                  Identifier name, SourceLoc nameLoc,
                                  ArrayRef<InheritedEntry> inherited,
@@ -9937,6 +9942,15 @@ void swift::simple_display(llvm::raw_ostream &out, AnyFunctionRef fn) {
     out << "closure";
 }
 
+bool ActorIsolation::isMainActor() const {
+  if (isGlobalActor()) {
+    if (auto *nominal = getGlobalActor()->getAnyNominal())
+      return nominal->isMainActor();
+  }
+
+  return false;
+}
+
 bool ActorIsolation::isDistributedActor() const {
   return getKind() == ActorInstance && getActor()->isDistributedActor();
 }

lib/AST/DiagnosticEngine.cpp

@@ -576,18 +576,6 @@ static bool typeSpellingIsAmbiguous(Type type,
   return false;
 }
 
-/// Determine whether this is the main actor type.
-static bool isMainActor(Type type) {
-  if (auto nominal = type->getAnyNominal()) {
-    if (nominal->getName().is("MainActor") &&
-        nominal->getParentModule()->getName() ==
-          nominal->getASTContext().Id_Concurrency)
-      return true;
-  }
-
-  return false;
-}
-
 void swift::printClangDeclName(const clang::NamedDecl *ND,
                                llvm::raw_ostream &os) {
   ND->getNameForDiagnostic(os, ND->getASTContext().getPrintingPolicy(), false);
@@ -841,10 +829,10 @@ static void formatDiagnosticArgument(StringRef Modifier,
 
     case ActorIsolation::GlobalActor:
     case ActorIsolation::GlobalActorUnsafe: {
-      Type globalActor = isolation.getGlobalActor();
-      if (isMainActor(globalActor)) {
+      if (isolation.isMainActor()) {
         Out << "main actor-isolated";
       } else {
+        Type globalActor = isolation.getGlobalActor();
         Out << "global actor " << FormatOpts.OpeningQuotationMark
           << globalActor.getString()
           << FormatOpts.ClosingQuotationMark << "-isolated";

lib/SILGen/SILGenProlog.cpp

@@ -929,6 +929,11 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
       !isInActorDestructor(FunctionDC) &&
       !F.isDefer();
 
+  // FIXME: Avoid loading and checking the expected executor if concurrency is
+  // unavailable. This is specifically relevant for MainActor isolated contexts,
+  // which are allowed to be available on OSes where concurrency is not
+  // available. rdar://106827064
+
   // Local function to load the expected executor from a local actor
   auto loadExpectedExecutorForLocalVar = [&](VarDecl *var) {
     auto loc = RegularLocation::getAutoGeneratedLocation(F.getLocation());

lib/Sema/TypeCheckAccess.cpp

@@ -1946,13 +1946,23 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
   explicit DeclAvailabilityChecker(ExportContext where)
     : Where(where) {}
 
+  void checkGlobalActor(Decl *D) {
+    auto globalActor = D->getGlobalActorAttr();
+    if (!globalActor)
+      return;
+
+    // Avoid checking the availability for a @MainActor constraint since it does
+    // not carry an inherent ABI impact.
+    if (globalActor->second->isMainActor())
+      return;
+
+    auto customAttr = globalActor->first;
+    checkType(customAttr->getType(), customAttr->getTypeRepr(), D);
+  }
+
   void visit(Decl *D) {
     DeclVisitor<DeclAvailabilityChecker>::visit(D);
-    
-    if (auto globalActor = D->getGlobalActorAttr()) {
-      auto customAttr = globalActor->first;
-      checkType(customAttr->getType(), customAttr->getTypeRepr(), D);
-    }
+    checkGlobalActor(D);
   }
 
   // Force all kinds to be handled at a lower level.

lib/Sema/TypeCheckAttr.cpp

@@ -3616,15 +3616,6 @@ void AttributeChecker::visitFrozenAttr(FrozenAttr *attr) {
   }
 }
 
-/// Determine whether this is the main actor type.
-/// FIXME: the diagnostics engine and TypeCheckConcurrency both have a copy of
-///        this
-static bool isMainActor(NominalTypeDecl *nominal) {
-  return nominal->getName().is("MainActor") &&
-         nominal->getParentModule()->getName() ==
-             nominal->getASTContext().Id_Concurrency;
-}
-
 void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
   auto dc = D->getDeclContext();
 
@@ -3667,7 +3658,7 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
     return;
   }
 
-  if (isMainActor(nominal) && Ctx.LangOpts.isConcurrencyModelTaskToThread() &&
+  if (nominal->isMainActor() && Ctx.LangOpts.isConcurrencyModelTaskToThread() &&
       !AvailableAttr::isUnavailable(D)) {
     Ctx.Diags.diagnose(attr->getLocation(),
                        diag::concurrency_task_to_thread_model_main_actor,

lib/Sema/TypeCheckConcurrency.cpp

@@ -1226,14 +1226,9 @@ void swift::diagnoseMissingExplicitSendable(NominalTypeDecl *nominal) {
 }
 
 /// Determine whether this is the main actor type.
-/// FIXME: the diagnostics engine has a copy of this.
 static bool isMainActor(Type type) {
-  if (auto nominal = type->getAnyNominal()) {
-    if (nominal->getName().is("MainActor") &&
-        nominal->getParentModule()->getName() ==
-          nominal->getASTContext().Id_Concurrency)
-      return true;
-  }
+  if (auto nominal = type->getAnyNominal())
+    return nominal->isMainActor();
 
   return false;
 }

test/Sema/availability_main_actor.swift

@@ -0,0 +1,20 @@
+// RUN: %target-typecheck-verify-swift
+
+// REQUIRES: concurrency
+
+// This test is meant to verify that a @MainActor constraint is accepted without
+// any availability restrictions for all targets.
+
+@MainActor
+struct AlwaysAvailable {}
+
+@MainActor(unsafe)
+struct AlwaysAvailableUnsafe {}
+
+@available(SwiftStdlib 5.1, *)
+@MainActor
+struct AvailableSwift5_1 {}
+
+@available(SwiftStdlib 5.1, *)
+@MainActor(unsafe)
+struct AvailableSwift5_1Unsafe {}

validation-test/ParseableInterface/unsafe-mainactor.swift

@@ -0,0 +1,14 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-emit-module-interface(%t/Library.swiftinterface) %s -module-name Library
+// RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -module-name Library
+// RUN: %FileCheck %s < %t/Library.swiftinterface
+
+// REQUIRES: OS=macosx
+
+import AppKit
+
+// CHECK: @objc @_inheritsConvenienceInitializers @_Concurrency.MainActor(unsafe) public class Subclass : AppKit.NSView {
+public class Subclass: NSView {
+  // CHECK: @_Concurrency.MainActor(unsafe) @objc override dynamic public init(frame frameRect: Foundation.NSRect)
+  // CHECK: @_Concurrency.MainActor(unsafe) @objc required dynamic public init?(coder: Foundation.NSCoder)
+}