[Diagnostics] Remove unhelpful notes from witness-isolation diagnostics

When diagnosing an isolation mismatch between a requirement and witness,
we would produce notes on the requirement itself suggesting the addition of
`async`. This is almost never what you want to do, and is often so far
away from the actual conforming type as to be useless. Remove this note,
and the non-function fallback that just points at the requirement, because
they are unhelpful.

This is staging for a rework of the way we deal with conformance-level
actor isolation problems.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -42,8 +42,6 @@ NOTE(opaque_return_type_declared_here,none,
      "opaque return type declared here", ())
 NOTE(default_value_declared_here,none,
      "default value declared here", ())
-NOTE(protocol_requirement_declared_here,none,
-     "requirement %0 declared here", (const ValueDecl *))
 
 //------------------------------------------------------------------------------
 // MARK: Constraint solver diagnostics
@@ -5440,10 +5438,6 @@ NOTE(note_add_async_to_function,none,
 NOTE(note_add_nonisolated_to_decl,none,
      "add 'nonisolated' to %0 to make this %kindonly0 not isolated to the actor",
      (const ValueDecl *))
-NOTE(note_add_async_and_throws_to_decl,none,
-     "mark the protocol requirement %0 '%select{|async|throws|async throws}1' "
-     "to allow actor-isolated conformances",
-     (const ValueDecl *, unsigned))
 NOTE(note_add_distributed_to_decl,none,
      "add 'distributed' to %0 to make this %kindonly0 satisfy the protocol requirement",
      (const ValueDecl *))

lib/Sema/TypeCheckProtocol.cpp

@@ -3599,64 +3599,6 @@ ConformanceChecker::checkActorIsolation(ValueDecl *requirement,
     }
   }
 
-  // If there are remaining options, they are missing async/throws on the
-  // requirement itself. If we have a source location for the requirement,
-  // provide those in a note.
-
-  if (requirement->getLoc().isInvalid()) {
-    return std::nullopt;
-  }
-
-  if (missingOptions && isa<AbstractFunctionDecl>(requirement)) {
-    int suggestAddingModifiers = 0;
-    std::string modifiers;
-    if (missingOptions.contains(MissingFlags::RequirementAsync)) {
-      suggestAddingModifiers += 1;
-      modifiers += "async ";
-    }
-
-    if (missingOptions.contains(MissingFlags::RequirementThrows)) {
-      suggestAddingModifiers += 2;
-      modifiers += "throws ";
-    }
-
-    auto diag = requirement->diagnose(diag::note_add_async_and_throws_to_decl,
-                                      witness, suggestAddingModifiers);
-
-    // Figure out where to insert the modifiers so we can emit a Fix-It.
-    SourceLoc insertLoc;
-    bool insertAfter = false;
-    if (auto requirementAbstractFunc =
-            dyn_cast<AbstractFunctionDecl>(requirement)) {
-      if (requirementAbstractFunc->getAsyncLoc().isValid()) {
-        // Insert before the "async" (we only have throws).
-        insertLoc = requirementAbstractFunc->getAsyncLoc();
-        insertAfter = true;
-        modifiers = " throws";
-      } else if (requirementAbstractFunc->getThrowsLoc().isValid()) {
-        // Insert before the "throws" (we only have async)".
-        insertLoc = requirementAbstractFunc->getThrowsLoc();
-      }
-
-      // Insert after the parentheses.
-      if (insertLoc.isInvalid()) {
-        insertLoc = requirementAbstractFunc->getParameters()->getRParenLoc();
-        insertAfter = true;
-        modifiers = " " + modifiers.substr(0, modifiers.size() - 1);
-      }
-    }
-
-    if (insertLoc.isValid()) {
-      if (insertAfter)
-        diag.fixItInsertAfter(insertLoc, modifiers);
-      else
-        diag.fixItInsert(insertLoc, modifiers);
-    }
-  } else {
-    requirement->diagnose(diag::protocol_requirement_declared_here,
-                          requirement);
-  }
-
   return std::nullopt;
 }
 

test/Concurrency/actor_isolation.swift

@@ -1504,7 +1504,7 @@ class MA {
 @SomeGlobalActor class SGA: MA {} // expected-error {{global actor 'SomeGlobalActor'-isolated class 'SGA' has different actor isolation from main actor-isolated superclass 'MA'}}
 
 protocol SGA_Proto {
-  @SomeGlobalActor func method() // expected-note {{mark the protocol requirement 'method()' 'async' to allow actor-isolated conformances}}
+  @SomeGlobalActor func method()
 }
 
 // try to override a MA method with inferred isolation from a protocol requirement
@@ -1614,7 +1614,7 @@ class OverridesNonsiolatedInit: SuperWithNonisolatedInit {
 class NonSendable {}
 
 protocol NonisolatedProtocol {
-  var ns: NonSendable { get } // expected-note {{requirement 'ns' declared here}}
+  var ns: NonSendable { get }
 }
 
 actor ActorWithNonSendableLet: NonisolatedProtocol {

test/Concurrency/actor_isolation_unsafe.swift

@@ -23,7 +23,7 @@ actor SomeGlobalActor {
 // ----------------------------------------------------------------------
 protocol P1 {
   // expected-warning@+1 {{'(unsafe)' global actors are deprecated; use '@preconcurrency' instead}}
-  @MainActor(unsafe) func onMainActor() // expected-note 2{{mark the protocol requirement 'onMainActor()' 'async' to allow actor-isolated conformances}}
+  @MainActor(unsafe) func onMainActor()
 }
 
 struct S1_P1: P1 {

test/Concurrency/global_actor_inference.swift

@@ -120,7 +120,7 @@ func testNotAllInP1(nap1: NotAllInP1) { // expected-note{{add '@SomeGlobalActor'
 // Make sure we don't infer 'nonisolated' for stored properties.
 @MainActor
 protocol Interface {
-  nonisolated var baz: Int { get } // expected-note{{requirement 'baz' declared here}}
+  nonisolated var baz: Int { get }
 }
 
 @MainActor

test/Concurrency/global_actor_inference_swift6.swift

@@ -155,7 +155,7 @@ struct S: InferMainActor {
 }
 
 protocol InferMainActorInherited: InferMainActor {
-  func f() // expected-note{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
+  func f()
   func g()
 }
 
@@ -198,7 +198,6 @@ class C1: MainActorSuperclass, InferMainFromSuperclass {
 
 protocol InferenceConflictWithSuperclass: MainActorSuperclass, InferSomeGlobalActor {
   func g()
-  // expected-note@-1 {{mark the protocol requirement 'g()' 'async' to allow actor-isolated conformances}}
 }
 
 

test/Concurrency/isolated_conformance.swift

@@ -4,7 +4,7 @@
 // REQUIRES: concurrency
 
 protocol P {
-  func f() // expected-note{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
+  func f()
 }
 
 // ----------------------------------------------------------------------------

test/Concurrency/isolated_conformance_default_actor.swift

@@ -6,7 +6,7 @@
 
 nonisolated
 protocol P {
-  func f() // expected-note{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
+  func f()
 }
 
 @MainActor

test/Concurrency/preconcurrency_conformances.swift

@@ -96,7 +96,6 @@ extension MyActor : @preconcurrency TestSendability {
 
 protocol Initializable {
   init()
-  // expected-note@-1{{mark the protocol requirement 'init()' 'async' to allow actor-isolated conformances}}
 }
 
 final class K : @preconcurrency Initializable {
@@ -130,10 +129,8 @@ struct GlobalActor {
 protocol WithIndividuallyIsolatedRequirements {
   @MainActor var a: Int { get set }
   @GlobalActor var b: Int { get set }
-  // expected-note@-1 {{requirement 'b' declared here}}
 
   @GlobalActor func test()
-  // expected-note@-1 {{mark the protocol requirement 'test()' 'async' to allow actor-isolated conformances}}
 }
 
 do {
@@ -158,9 +155,7 @@ do {
 @MainActor
 protocol WithNonIsolated {
   var prop: Int { get set }
-  // expected-note@-1 {{requirement 'prop' declared here}}
   nonisolated func test()
-  // expected-note@-1 {{mark the protocol requirement 'test()' 'async' to allow actor-isolated conformances}}
 }
 
 do {
@@ -212,7 +207,7 @@ do {
 do {
   protocol P1 {}
   protocol P2 {
-    func foo() // expected-note 2 {{mark the protocol requirement 'foo()' 'async' to allow actor-isolated conformances}}
+    func foo()
   }
   protocol P3: P1, P2 {}
 
@@ -278,7 +273,7 @@ do {
 do {
   protocol P1 {}
   protocol P2 {
-    func foo() // expected-note {{mark the protocol requirement 'foo()' 'async' to allow actor-isolated conformances}}
+    func foo()
   }
   protocol P3: P1, P2 {}
   protocol P5: P3 {}

test/Concurrency/predates_concurrency.swift

@@ -227,7 +227,6 @@ nonisolated func blah() {
 
 protocol NotIsolated {
   func requirement()
-  // expected-complete-tns-note@-1 {{mark the protocol requirement 'requirement()' 'async' to allow actor-isolated conformances}}
 }
 
 extension MainActorPreconcurrency: NotIsolated {

test/Distributed/distributed_protocol_isolation.swift

@@ -96,13 +96,10 @@ func outside_good_ext<DP: DistProtocol>(dp: DP) async throws {
 /// A distributed actor could only conform to this by making everything 'nonisolated':
 protocol StrictlyLocal {
   func local()
-  // expected-note@-1 2{{mark the protocol requirement 'local()' 'async throws' to allow actor-isolated conformances}}{{15-15= async throws}}
 
   func localThrows() throws
-  // expected-note@-1 2{{mark the protocol requirement 'localThrows()' 'async' to allow actor-isolated conformances}}{{22-22=async }}
 
   func localAsync() async
-  // expected-note@-1 2{{mark the protocol requirement 'localAsync()' 'throws' to allow actor-isolated conformances}}
 }
 
 distributed actor Nope1_StrictlyLocal: StrictlyLocal {
@@ -141,7 +138,6 @@ actor MyServer : Server {
 
 protocol AsyncThrowsAll {
   func maybe(param: String, int: Int) async throws -> Int
-  // expected-note@-1{{'maybe(param:int:)' declared here}}
 }
 
 actor LocalOK_AsyncThrowsAll: AsyncThrowsAll {
@@ -191,7 +187,6 @@ func testAsyncThrowsAll(p: AsyncThrowsAll,
 
 protocol TerminationWatchingA {
   func terminated(a: String) async
-  // expected-note@-1{{mark the protocol requirement 'terminated(a:)' 'throws' to allow actor-isolated conformances}}
 }
 
 protocol TerminationWatchingDA: DistributedActor {

test/decl/class/actor/conformance.swift

@@ -15,20 +15,20 @@ extension MyActor: AsyncProtocol {
 }
 
 protocol SyncProtocol {
-  var propertyA: Int { get } // expected-note{{requirement 'propertyA' declared here}}
-  var propertyB: Int { get set } // expected-note{{requirement 'propertyB' declared here}}
+  var propertyA: Int { get }
+  var propertyB: Int { get set }
 
-  func syncMethodA() // expected-note{{mark the protocol requirement 'syncMethodA()' 'async' to allow actor-isolated conformances}}{{21-21= async}}
+  func syncMethodA()
 
   func syncMethodC() -> Int
 
-  func syncMethodE() -> Void // expected-note{{mark the protocol requirement 'syncMethodE()' 'async' to allow actor-isolated conformances}}{{21-21= async}}
+  func syncMethodE() -> Void
 
-  func syncMethodF(param: String) -> Int // expected-note{{mark the protocol requirement 'syncMethodF(param:)' 'async' to allow actor-isolated conformances}}{{34-34= async}}
+  func syncMethodF(param: String) -> Int
 
-  func syncMethodG() throws -> Void // expected-note{{mark the protocol requirement 'syncMethodG()' 'async' to allow actor-isolated conformances}}{{22-22=async }}
+  func syncMethodG() throws -> Void
 
-  subscript (index: Int) -> String { get } // expected-note{{requirement 'subscript(_:)' declared here}}
+  subscript (index: Int) -> String { get }
 
   static func staticMethod()
   static var staticProperty: Int { get }

test/decl/class/actor/global_actor_conformance.swift

@@ -18,9 +18,9 @@ protocol P1 {
   associatedtype Assoc
 
   @GlobalActor func method1()
-  @GenericGlobalActor<Int> func method2()  // expected-note{{}}
+  @GenericGlobalActor<Int> func method2()
   @GenericGlobalActor<Assoc> func method3()
-  func method4() // expected-note{{mark the protocol requirement 'method4()' 'async' to allow actor-isolated conformances}}
+  func method4()
 }
 
 protocol P2 {
@@ -47,7 +47,6 @@ class C1 : P1, P2 {
 }
 
 protocol NonIsolatedRequirement {
-  // expected-note@+1 {{mark the protocol requirement 'requirement()' 'async' to allow actor-isolated conformances}}
   func requirement()
 }
 

test/decl/protocol/special/DistributedActor.swift

@@ -55,7 +55,6 @@ distributed actor D4 {
 
 protocol P1: DistributedActor {
   distributed func dist() -> String
-  // expected-note@-1{{requirement 'dist()' declared here}}
 }
 
 distributed actor D5: P1 {
@@ -78,7 +77,6 @@ func testConformance() {
 // https://github.com/apple/swift/issues/69244
 protocol P {
   func foo() -> Void
-  // expected-note@-1{{mark the protocol requirement 'foo()' 'async throws' to allow actor-isolated conformances}}{{13-13= async throws}}
 }
 
 distributed actor A: P {