Cleanup actor protocol conformance error

This patch cleans up how we emit the errors for disallowing the
properties and methods of an actor to be applied to the protocol
conformance. Rather than having multiple error messages for each case,
we keep one error message saying that the actor-isolated
method/variable/what-have-you cannot be used to satisfy a protocol
requirement, then allow multiple notes with fix-its to allow the
programmer to choose what they want to do. The notes have a better
description of what each option does.

Author: etcwilde

include/swift/AST/DiagnosticsSema.def

@@ -4132,6 +4132,9 @@ NOTE(note_add_async_to_function,none,
      "add 'async' to function %0 to make it asynchronous", (DeclName))
 NOTE(note_add_asynchandler_to_function,none,
      "add '@asyncHandler' to function %0 to create an implicit asynchronous context", (DeclName))
+NOTE(note_add_actorindependent_to_decl,none,
+     "add '@actorIndependent' to %0 to make this %1 independent of the actor",
+     (DeclName, DescriptiveDeclKind))
 NOTE(note_add_globalactor_to_function,none,
      "add '@%0' to make %1 %2 part of global actor %3", 
      (StringRef, DescriptiveDeclKind, DeclName, Type))
@@ -4255,10 +4258,6 @@ WARNING(shared_mutable_state_access,none,
 ERROR(actor_isolated_witness,none,
      "actor-isolated %0 %1 cannot be used to satisfy a protocol requirement",
      (DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_witness_could_be_async_handler,none,
-     "actor-isolated %0 %1 cannot be used to satisfy a protocol requirement; "
-     "did you mean to make it an asychronous handler?",
-     (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",

lib/Sema/TypeCheckProtocol.cpp

@@ -2654,20 +2654,29 @@ bool ConformanceChecker::checkActorIsolation(
               ActorIsolationRestriction::forDeclaration(witness)) {
   case ActorIsolationRestriction::ActorSelf: {
     // Actor-isolated witnesses cannot conform to protocol requirements.
-    bool canBeAsyncHandler = false;
+    witness->diagnose(diag::actor_isolated_witness,
+                      witness->getDescriptiveKind(),
+                      witness->getName());
     if (auto witnessFunc = dyn_cast<FuncDecl>(witness)) {
-      canBeAsyncHandler = !witnessFunc->isAsyncHandler() &&
       witnessFunc->canBeAsyncHandler();
+      if (!witnessFunc->isAsyncHandler()) {
+        auto handlerNote = witness->diagnose(
+            diag::note_add_asynchandler_to_function,
+            witness->getName());
+        handlerNote.fixItInsert(witness->getAttributeInsertionLoc(false),
+            "@asyncHandler ");
+      }
     }
-    auto diag = witness->diagnose(
-        canBeAsyncHandler
-            ? diag::actor_isolated_witness_could_be_async_handler
-            : diag::actor_isolated_witness,
-        witness->getDescriptiveKind(), witness->getName());
-
-    if (canBeAsyncHandler) {
-      diag.fixItInsert(
-         witness->getAttributeInsertionLoc(false), "@asyncHandler ");
+
+    {
+      auto witnessVar = dyn_cast<VarDecl>(witness);
+      if ((witnessVar && !witnessVar->hasStorage()) || !witnessVar) {
+        auto independentNote = witness->diagnose(
+            diag::note_add_actorindependent_to_decl,
+            witness->getName(), witness->getDescriptiveKind());
+        independentNote.fixItInsert(witness->getAttributeInsertionLoc(false),
+            "@actorIndependent ");
+      }
     }
 
     return true;

test/decl/class/actor/conformance.swift

@@ -37,9 +37,12 @@ actor class OtherActor: SyncProtocol {
 
   var propertyA: Int { 17 }
   // expected-error@-1{{actor-isolated property 'propertyA' cannot be used to satisfy a protocol requirement}}
+  // expected-note@-2{{add '@actorIndependent' to 'propertyA' to make this property independent of the actor}}{{3-3=@actorIndependent }}
 
   func syncMethodA() { }
-  // expected-error@-1{{actor-isolated instance method 'syncMethodA()' cannot be used to satisfy a protocol requirement; did you mean to make it an asychronous handler?}}{{3-3=@asyncHandler }}
+  // expected-error@-1{{actor-isolated instance method 'syncMethodA()' cannot be used to satisfy a protocol requirement}}
+  // expected-note@-2{{add '@actorIndependent' to 'syncMethodA()' to make this instance method independent of the actor}}{{3-3=@actorIndependent }}
+  // expected-note@-3{{add '@asyncHandler' to function 'syncMethodA()' to create an implicit asynchronous context}}{{3-3=@asyncHandler }}
 
   // Async handlers are okay.
   @asyncHandler
@@ -51,6 +54,7 @@ actor class OtherActor: SyncProtocol {
 
   subscript (index: Int) -> String { "\(index)" }
   // expected-error@-1{{actor-isolated subscript 'subscript(_:)' cannot be used to satisfy a protocol requirement}}
+  // expected-note@-2{{add '@actorIndependent' to 'subscript(_:)' to make this subscript independent of the actor}}{{3-3=@actorIndependent }}
 
   // Static methods and properties are okay.
   static func staticMethod() { }

test/decl/protocol/special/Actor.swift

@@ -41,7 +41,9 @@ class C1: Actor {
 
 // Method that is not usable as a witness.
 actor class BA1 {
-  func enqueue(partialTask: PartialAsyncTask) { } // expected-error{{actor-isolated instance method 'enqueue(partialTask:)' cannot be used to satisfy a protocol requirement; did you mean to make it an asychronous handler?}}
+  func enqueue(partialTask: PartialAsyncTask) { } // expected-error{{actor-isolated instance method 'enqueue(partialTask:)' cannot be used to satisfy a protocol requirement}}
+  //expected-note@-1{{add '@asyncHandler' to function 'enqueue(partialTask:)' to create an implicit asynchronous context}}{{3-3=@asyncHandler }}
+  //expected-note@-2{{add '@actorIndependent' to 'enqueue(partialTask:)' to make this instance method independent of the actor}}{{3-3=@actorIndependent }}
 }
 
 // Method that isn't part of the main class definition cannot be used to