[Sema] Propagate @preconcurrency attribute to grouped diagnostics feature

Author: angela-laar

lib/Sema/TypeCheckConcurrency.cpp

@@ -2147,21 +2147,25 @@ namespace {
 
         auto behavior = DiagnosticBehavior::Error;
 
+        // Limit behavior if @preconcurrency detected
+        if (errors.front().preconcurrency)
+          behavior = DiagnosticBehavior::Warning;
+
         // Add Fix-it for missing @SomeActor annotation
         if (isolation.isGlobalActor()) {
           if (missingGlobalActorOnContext(
                   const_cast<DeclContext *>(getDeclContext()),
                   isolation.getGlobalActor(), behavior) &&
               errors.size() > 1) {
-            behavior= DiagnosticBehavior::Note;
+            behavior = DiagnosticBehavior::Note;
           }
         }
 
         for (IsolationError error : errors) {
           // Diagnose actor_isolated_non_self_reference as note
-          // if fix-it provided in missingGlobalActorOnContext
+          // if there are multiple of these diagnostics
           ctx.Diags.diagnose(error.loc, error.diag)
-              .limitBehaviorUntilSwiftVersion(behavior, 6);
+            .limitBehaviorUntilSwiftVersion(behavior, 6);
         }
       }
 
@@ -2172,21 +2176,26 @@ namespace {
 
         auto behavior = DiagnosticBehavior::Error;
 
+        // Limit behavior if @preconcurrency detected
+        if (errors.front().preconcurrency)
+          behavior = DiagnosticBehavior::Warning;
+
         // Add Fix-it for missing @SomeActor annotation
         if (isolation.isGlobalActor()) {
           if (missingGlobalActorOnContext(
                   const_cast<DeclContext *>(getDeclContext()),
                   isolation.getGlobalActor(), behavior) &&
               errors.size() > 1) {
-            behavior= DiagnosticBehavior::Note;
+            behavior = DiagnosticBehavior::Note;
           }
         }
 
         for (IsolationError error : errors) {
           // Diagnose actor_isolated_call as note if
-          // fix-it provided in missingGlobalActorOnContext
-          ctx.Diags.diagnose(error.loc, error.diag)
-              .limitBehaviorUntilSwiftVersion(behavior, 6);
+          // if there are multiple actor-isolated function calls
+          // from outside the actor
+            ctx.Diags.diagnose(error.loc, error.diag)
+            .limitBehaviorUntilSwiftVersion(behavior, 6);
         }
       }
 
@@ -3449,15 +3458,19 @@ namespace {
 
           IsolationError mismatch([calleeDecl, apply, unsatisfiedIsolation, getContextIsolation]() {
             if (calleeDecl) {
+              auto preconcurrency = getContextIsolation().preconcurrency() || getActorIsolation(calleeDecl).preconcurrency();
+
               return IsolationError(
                              apply->getLoc(),
+                             preconcurrency,
                              Diagnostic(diag::actor_isolated_call_decl,
                                         *unsatisfiedIsolation,
                                         calleeDecl,
                                         getContextIsolation()));
             } else {
               return IsolationError(
                              apply->getLoc(),
+                             getContextIsolation().preconcurrency(),
                              Diagnostic(diag::actor_isolated_call,
                                         *unsatisfiedIsolation,
                                         getContextIsolation()));
@@ -3475,8 +3488,8 @@ namespace {
           }
         } else {
           if (calleeDecl) {
-            auto preconcurrency = getContextIsolation().preconcurrency() ||
-                getActorIsolation(calleeDecl).preconcurrency();
+            auto preconcurrency = getContextIsolation().preconcurrency() || getActorIsolation(calleeDecl).preconcurrency();
+
             ctx.Diags.diagnose(
                                apply->getLoc(), diag::actor_isolated_call_decl,
                                *unsatisfiedIsolation,
@@ -3979,6 +3992,7 @@ namespace {
 
         if (ctx.LangOpts.hasFeature(Feature::GroupActorErrors)) {
           IsolationError mismatch = IsolationError(loc,
+              preconcurrencyContext,
               Diagnostic(diag::actor_isolated_non_self_reference,
                   decl, useKind, refKind + 1, refGlobalActor,
                   result.isolation));

lib/Sema/TypeCheckConcurrency.h

@@ -254,10 +254,12 @@ struct IsolationError {
 
   SourceLoc loc;
 
+  bool preconcurrency;
+  
   Diagnostic diag;
 
 public:
-  IsolationError(SourceLoc loc, Diagnostic diag) : loc(loc), diag(diag) {}
+  IsolationError(SourceLoc loc, bool preconcurrency, Diagnostic diag) : loc(loc), preconcurrency(preconcurrency), diag(diag) {}
 
 };
 

test/Concurrency/grouped_actor_isolation_diagnostics.swift

@@ -7,22 +7,34 @@ protocol P {
   nonisolated func g()
 }
 
-struct S_P: P {
+struct S: P {
   func f() { }
   func g() { }
 }
 
-// expected-error@+2{{calls to '@MainActor'-isolated' code in global function 'testP(x:p:)'}}
-// expected-note@+1{{add '@MainActor' to make global function 'testP(x:p:)' part of global actor 'MainActor'}}
-func testP(x: S_P, p: P) {
+@preconcurrency struct NonConcurrentS: P {
+  func f() { }
+  func g() { }
+}
+
+// expected-note@+1{{add '@MainActor' to make global function 'testP(s:p:)' part of global actor 'MainActor'}}
+func testP(s: S, p: P) { // expected-error {{calls to '@MainActor'-isolated' code in global function 'testP(s:p:)'}}
+
   p.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
   p.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
   p.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
   p.g() // OKAY
-  x.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
-  x.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
-  x.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
-  x.g() // OKAY
+  s.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
+  s.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
+  s.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
+  s.g() // OKAY
+}
+// expected-note @+1{{add '@MainActor' to make global function 'testPreconcurrencyP(ncs:)' part of global actor 'MainActor'}}
+func testPreconcurrencyP(ncs: NonConcurrentS) { // expected-error {{calls to '@MainActor'-isolated' code in global function 'testPreconcurrencyP(ncs:)'}}
+  ncs.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
+  ncs.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
+  ncs.f() // expected-note{{call to main actor-isolated instance method 'f()' in a synchronous nonisolated context}}
+  ncs.g() // OKAY
 }
 
 actor SomeActor { }
@@ -46,7 +58,7 @@ struct WrapperOnActor<Wrapped: Sendable> {
   }
 
   @SomeGlobalActor var projectedValue: Wrapped {
-    get {  }
+    get { }
     set { }
   }
 }
@@ -81,3 +93,15 @@ struct HasWrapperOnActor {
     testMA() // expected-error{{call to main actor-isolated instance method 'testMA()' in a synchronous nonisolated context}}
   }
 }
+
+@preconcurrency @MainActor
+class MainActorPreconcurrency {}
+
+class InferMainActorPreconcurrency: MainActorPreconcurrency {
+  static func predatesConcurrency() {}
+}
+
+nonisolated func testPreconcurrency() {
+  InferMainActorPreconcurrency.predatesConcurrency()
+  // expected-warning@-1 {{call to main actor-isolated static method 'predatesConcurrency()' in a synchronous nonisolated context}}
+}