Sema: Diagnose use of global actor types with insufficient access on @usableFromInline declarations.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -4887,6 +4887,9 @@ ERROR(global_actor_access,none,
       "cannot have %select{private|fileprivate|internal|%error|%error}3 "
       "global actor %4",
       (AccessLevel, DescriptiveDeclKind, DeclName, AccessLevel, DeclName))
+ERROR(global_actor_not_usable_from_inline,none,
+      "global actor for %0 %1 must be '@usableFromInline' or public",
+      (DescriptiveDeclKind, DeclName))
 
 ERROR(actor_isolation_multiple_attr,none,
       "%0 %1 has multiple actor-isolation attributes ('%2' and '%3')",

lib/Sema/TypeCheckAccess.cpp

@@ -109,7 +109,7 @@ class AccessControlCheckerBase {
     const GenericContext *ownerCtx,
     const ValueDecl *ownerDecl);
 
-  void checkGlobalActorAccess(const ValueDecl *D);
+  void checkGlobalActorAccess(const Decl *D);
 };
 
 class TypeAccessScopeDiagnoser : private ASTWalker {
@@ -411,25 +411,36 @@ void AccessControlCheckerBase::checkGenericParamAccess(
                           ownerDecl->getFormalAccess());
 }
 
-void AccessControlCheckerBase::checkGlobalActorAccess(const ValueDecl *D) {
+void AccessControlCheckerBase::checkGlobalActorAccess(const Decl *D) {
+  auto VD = dyn_cast<ValueDecl>(D);
+  if (!VD)
+    return;
+
   auto globalActorAttr = D->getGlobalActorAttr();
   if (!globalActorAttr)
     return;
 
   auto customAttr = globalActorAttr->first;
   auto globalActorDecl = globalActorAttr->second;
   checkTypeAccess(
-      customAttr->getType(), customAttr->getTypeRepr(), D,
+      customAttr->getType(), customAttr->getTypeRepr(), VD,
       /*mayBeInferred*/ false,
       [&](AccessScope typeAccessScope, const TypeRepr *complainRepr,
           DowngradeToWarning downgradeToWarning) {
+        if (checkUsableFromInline) {
+          auto diag = D->diagnose(diag::global_actor_not_usable_from_inline,
+                                  D->getDescriptiveKind(), VD->getName());
+          highlightOffendingType(diag, complainRepr);
+          return;
+        }
+
         auto globalActorAccess = typeAccessScope.accessLevelForDiagnostics();
         bool isExplicit = D->getAttrs().hasAttribute<AccessControlAttr>();
         auto declAccess = isExplicit
-                              ? D->getFormalAccess()
+                              ? VD->getFormalAccess()
                               : typeAccessScope.requiredAccessForDiagnostics();
         auto diag = D->diagnose(diag::global_actor_access, declAccess,
-                                D->getDescriptiveKind(), D->getName(),
+                                D->getDescriptiveKind(), VD->getName(),
                                 globalActorAccess, globalActorDecl->getName());
         highlightOffendingType(diag, complainRepr);
       });
@@ -451,9 +462,7 @@ class AccessControlChecker : public AccessControlCheckerBase,
       return;
 
     DeclVisitor<AccessControlChecker>::visit(D);
-
-    if (const auto *VD = dyn_cast<ValueDecl>(D))
-      checkGlobalActorAccess(VD);
+    checkGlobalActorAccess(D);
   }
 
   // Force all kinds to be handled at a lower level.
@@ -1076,6 +1085,7 @@ class UsableFromInlineChecker : public AccessControlCheckerBase,
         return;
 
     DeclVisitor<UsableFromInlineChecker>::visit(D);
+    checkGlobalActorAccess(D);
   }
 
   // Force all kinds to be handled at a lower level.

test/attr/attr_inlinable_global_actor.swift

@@ -0,0 +1,33 @@
+// RUN: %target-typecheck-verify-swift -swift-version 5
+
+// REQUIRES: concurrency
+
+@globalActor
+private struct PrivateGA { // expected-note 2 {{type declared here}}
+  actor Actor {}
+  static let shared = Actor()
+}
+
+@globalActor
+internal struct InternalGA { // expected-note {{type declared here}}
+  actor Actor {}
+  static let shared = Actor()
+}
+
+@globalActor @usableFromInline
+internal struct UFIGA {
+  @usableFromInline actor Actor {}
+  @usableFromInline static let shared = Actor()
+}
+
+@globalActor
+public struct PublicGA {
+  public actor Actor {}
+  public static let shared = Actor()
+}
+
+// expected-error@+1 {{internal struct 'UFIStructPrivateGA' cannot have private global actor 'PrivateGA'}}
+@PrivateGA @usableFromInline internal struct UFIStructPrivateGA {} // expected-error {{global actor for struct 'UFIStructPrivateGA' must be '@usableFromInline' or public}}
+@InternalGA @usableFromInline internal struct UFIStructInternalGA {} // expected-error {{global actor for struct 'UFIStructInternalGA' must be '@usableFromInline' or public}}
+@UFIGA @usableFromInline internal struct UFIStructUFIGA {}
+@PublicGA @usableFromInline internal struct UFIStructPublicGA {}