Teach witness matching to apply minimal/strict diagnostics rules.

This downgrades some errors to warnings in Swift 5 mode, and ensures that
we diagnose all conditions in Swift 6 mode.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4553,10 +4553,6 @@ ERROR(actor_isolated_witness,none,
 ERROR(distributed_actor_isolated_witness,none,
      "distributed actor-isolated %0 %1 cannot be used to satisfy a protocol requirement",
      (DescriptiveDeclKind, DeclName))
-ERROR(global_actor_isolated_requirement,none,
-      "%0 %1 must be isolated to the global actor %2 to satisfy corresponding "
-      "requirement from protocol %3",
-      (DescriptiveDeclKind, DeclName, Type, Identifier))
 ERROR(global_actor_isolated_witness,none,
       "%0 %1 isolated to global actor %2 can not satisfy corresponding "
       "requirement from protocol %3",

lib/Sema/TypeCheckProtocol.cpp

@@ -2868,6 +2868,8 @@ bool ConformanceChecker::checkActorIsolation(
   // unsuitable as a witness.
   bool isCrossActor = false;
   bool witnessIsUnsafe = false;
+  DiagnosticBehavior behavior = SendableCheckContext(
+      witness->getInnermostDeclContext()).defaultDiagnosticBehavior();
   Type witnessGlobalActor;
   switch (auto witnessRestriction =
               ActorIsolationRestriction::forDeclaration(
@@ -3091,8 +3093,6 @@ bool ConformanceChecker::checkActorIsolation(
   }
 
   case ActorIsolationRestriction::Unsafe:
-    break;
-
   case ActorIsolationRestriction::Unrestricted:
     // The witness is completely unrestricted, so ignore any annotations on
     // the requirement.
@@ -3155,53 +3155,34 @@ bool ConformanceChecker::checkActorIsolation(
   // However, we allow this case when the requirement was imported, because
   // it might not have been annotated.
   if (witnessGlobalActor && !requirementGlobalActor) {
-    // If the requirement was imported from Objective-C, it may not have been
-    // annotated appropriately. Allow the mismatch.
+    // If the requirement was imported from Objective-C, downgrade to a warning
+    // because it may not have been annotated appropriately.
     if (requirement->hasClangNode())
-      return false;
-
-    // If the witness is "unsafe", allow the mismatch.
-    if (witnessIsUnsafe)
-      return false;
+      behavior = std::max(behavior, DiagnosticBehavior::Warning);
 
     witness->diagnose(
         diag::global_actor_isolated_witness, witness->getDescriptiveKind(),
-        witness->getName(), witnessGlobalActor, Proto->getName());
+        witness->getName(), witnessGlobalActor, Proto->getName())
+      .limitBehavior(behavior);
     requirement->diagnose(diag::decl_declared_here, requirement->getName());
-    return true;
+    return behavior == DiagnosticBehavior::Unspecified;
   }
 
-  // If the requirement has a global actor but the witness does not, we have
-  // an isolation error.
+  // If the requirement has a global actor but the witness does not, it's
+  // fine.
   if (requirementGlobalActor && !witnessGlobalActor) {
-    // If the requirement's global actor was "unsafe", we allow this.
-    if (requirementIsUnsafe)
-      return false;
-
-    if (isCrossActor) {
-      return diagnoseNonSendableTypesInReference(
-        witness, DC, witness->getLoc(),
-        ConcurrentReferenceKind::CrossActor);
-    }
-
-    witness->diagnose(
-        diag::global_actor_isolated_requirement, witness->getDescriptiveKind(),
-        witness->getName(), requirementGlobalActor, Proto->getName())
-      .fixItInsert(
-        witness->getAttributeInsertionLoc(/*forModifier=*/false),
-      "@" + requirementGlobalActor.getString());
-    requirement->diagnose(diag::decl_declared_here, requirement->getName());
-    return true;
+    return false;
   }
 
   // Both have global actors but they differ, so this is an isolation error.
   assert(!witnessGlobalActor->isEqual(requirementGlobalActor));
   witness->diagnose(
       diag::global_actor_isolated_requirement_witness_conflict,
       witness->getDescriptiveKind(), witness->getName(), witnessGlobalActor,
-      Proto->getName(), requirementGlobalActor);
+      Proto->getName(), requirementGlobalActor)
+    .limitBehavior(behavior);
   requirement->diagnose(diag::decl_declared_here, requirement->getName());
-  return true;
+  return behavior == DiagnosticBehavior::Unspecified;
 }
 
 bool ConformanceChecker::checkObjCTypeErasedGenerics(

test/Concurrency/actor_isolation_unsafe.swift

@@ -30,7 +30,7 @@ struct S3_P1: P1 {
 }
 
 struct S4_P1: P1 {
-  @SomeGlobalActor func onMainActor() { } // expected-error{{instance method 'onMainActor()' isolated to global actor 'SomeGlobalActor' can not satisfy corresponding requirement from protocol 'P1' isolated to global actor 'MainActor'}}
+  @SomeGlobalActor func onMainActor() { } // expected-warning{{instance method 'onMainActor()' isolated to global actor 'SomeGlobalActor' can not satisfy corresponding requirement from protocol 'P1' isolated to global actor 'MainActor'}}
 }
 
 @MainActor(unsafe)

test/Concurrency/global_actor_inference.swift

@@ -47,7 +47,7 @@ protocol P1 {
 }
 
 protocol P2 {
-  @SomeGlobalActor func method1() // expected-note {{'method1()' declared here}}
+  @SomeGlobalActor func method1()
   func method2()
 }
 
@@ -146,14 +146,12 @@ class C5 {
 }
 
 protocol P3 {
-  @OtherGlobalActor func method1() // expected-note{{'method1()' declared here}}
+  @OtherGlobalActor func method1()
   func method2()
 }
 
 class C6: P2, P3 {
   func method1() { }
-    // expected-error@-1{{instance method 'method1()' must be isolated to the global actor 'SomeGlobalActor' to satisfy corresponding requirement from protocol 'P2'}}
-    // expected-error@-2{{instance method 'method1()' must be isolated to the global actor 'OtherGlobalActor' to satisfy corresponding requirement from protocol 'P3'}}
   func method2() { }
 
   func testMethod() {

test/decl/class/actor/global_actor_conformance.swift

@@ -33,9 +33,9 @@ class C1 : P1, P2 {
 
   func method1() { }
 
-  @GenericGlobalActor<String> func method2() { } // expected-error{{instance method 'method2()' isolated to global actor 'GenericGlobalActor<String>' can not satisfy corresponding requirement from protocol 'P1' isolated to global actor 'GenericGlobalActor<Int>'}}
+  @GenericGlobalActor<String> func method2() { } // expected-warning{{instance method 'method2()' isolated to global actor 'GenericGlobalActor<String>' can not satisfy corresponding requirement from protocol 'P1' isolated to global actor 'GenericGlobalActor<Int>'}}
   @GenericGlobalActor<String >func method3() { }
-  @GlobalActor func method4() { } // expected-error{{instance method 'method4()' isolated to global actor 'GlobalActor' can not satisfy corresponding requirement from protocol 'P1'}}
+  @GlobalActor func method4() { } // expected-warning{{instance method 'method4()' isolated to global actor 'GlobalActor' can not satisfy corresponding requirement from protocol 'P1'}}
 
   // Okay: we can ignore the mismatch in global actor types for 'async' methods.
   func asyncMethod1() async { }