[Concurrency] A declaration is only 'nonisolated' if it has an explicit 'nonisolated' attribute.

Author: simanerush

lib/Sema/TypeCheckConcurrency.cpp

@@ -4912,6 +4912,13 @@ getIsolationFromConformances(NominalTypeDecl *nominal) {
   if (isa<ProtocolDecl>(nominal))
     return std::nullopt;
 
+  if (nominal->getAttrs().getAttribute<NonisolatedAttr>()) {
+    return InferredActorIsolation {
+      getActorIsolationOfContext(nominal->getDeclContext()),
+      IsolationSource(nominal, IsolationSource::LexicalContext)
+    };
+  }
+
   std::optional<InferredActorIsolation> foundIsolation;
   for (auto conformance :
        nominal->getLocalConformances(ConformanceLookupKind::NonStructural)) {
@@ -5467,14 +5474,6 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
     value->getAttrs().add(preconcurrency);
   }
 
-  // If this declaration is non-isolated, we are done.
-  auto ctxIsolation = getActorIsolationOfContext(dc);
-  if (ctxIsolation.isNonisolated()) {
-    return {
-      ctxIsolation,
-      IsolationSource(dc->getAsDecl(), IsolationSource::LexicalContext)};
-  }
-
   if (FuncDecl *fd = dyn_cast<FuncDecl>(value)) {
     // Main.main() and Main.$main are implicitly MainActor-protected.
     // Any other isolation is an error.

test/Concurrency/nonisolated_rules.swift

@@ -47,6 +47,17 @@ nonisolated struct NonisolatedStruct: GloballyIsolated {
   struct Nested {} // 'Nested' is not @MainActor-isolated
 }
 
+// expected-note@+1 {{calls to global function 'requireMain()' from outside of its actor context are implicitly asynchronous}}
+@MainActor func requireMain() {}
+
+nonisolated struct S1: GloballyIsolated {
+  var x: NonSendable
+  func f() {
+    // expected-error@+1 {{call to main actor-isolated global function 'requireMain()' in a synchronous nonisolated context}}
+    requireMain()
+  }
+}
+
 // MARK: - Protocols
 
 nonisolated protocol Refined: GloballyIsolated {}