[Diagnostics] Adjust @execution(...) diagnostic to take DeclAttribute or StringRef

It has been decided to split the attribute into `@concurrent` and
`nonisolated(nonsending`. Adjusting diagnostics to accept the attribute
makes the transition easier.

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -8553,40 +8553,47 @@ GROUPED_ERROR(isolated_conformance_wrong_domain,IsolatedConformances,none,
 // MARK: @execution Attribute
 //===----------------------------------------------------------------------===//
 
-ERROR(attr_execution_only_on_async,none,
-      "cannot use '@execution' on non-async %kind0",
-      (ValueDecl *))
+ERROR(execution_behavior_only_on_async,none,
+      "cannot use '%0' on non-async %kind1",
+      (DeclAttribute, ValueDecl *))
 
-ERROR(attr_execution_only_on_async_closure,none,
-      "cannot use '@execution' on non-async closure",
-      ())
+ERROR(execution_behavior_only_on_async_closure,none,
+      "cannot use '%0' on non-async closure",
+      (DeclAttribute))
 
-ERROR(attr_execution_type_attr_only_on_async,none,
-      "cannot use '@execution' on non-async function type",
-      ())
+ERROR(execution_behavior_type_attr_only_on_async,none,
+      "cannot use '@%0' on non-async function type",
+      (StringRef))
 
-ERROR(attr_execution_incompatible_isolated_parameter,none,
-      "cannot use '@execution' on %kind0 because it has "
-      "an isolated parameter: %1",
-      (ValueDecl *, ValueDecl *))
+ERROR(execution_behavior_incompatible_isolated_parameter,none,
+      "cannot use '%0' on %kind1 because it has "
+      "an isolated parameter: %2",
+      (DeclAttribute, ValueDecl *, ValueDecl *))
 
-ERROR(attr_execution_incompatible_dynamically_isolated_parameter,none,
-      "cannot use '@execution' on %kind0 because it has "
-      "a dynamically isolated parameter: %1",
-      (ValueDecl *, ValueDecl *))
+ERROR(execution_behavior_incompatible_dynamically_isolated_parameter,none,
+      "cannot use '%0' on %kind1 because it has "
+      "a dynamically isolated parameter: %2",
+      (DeclAttribute, ValueDecl *, ValueDecl *))
 
-ERROR(attr_execution_type_attr_incompatible_with_global_isolation,none,
-      "cannot use '@execution' because function type is "
-      "isolated to a global actor %0",
-      (Type))
+ERROR(execution_behavior_attr_incompatible_with_global_isolation,none,
+      "cannot use '%0' because function type is isolated to a global actor %1",
+      (DeclAttribute, Type))
 
-ERROR(attr_execution_type_attr_incompatible_with_isolated_param,none,
-      "cannot use '@execution' together with an isolated parameter",
-      ())
+ERROR(execution_behavior_attr_incompatible_with_isolated_param,none,
+      "cannot use '%0' together with an isolated parameter",
+      (DeclAttribute))
 
-ERROR(attr_execution_type_attr_incompatible_with_isolated_any,none,
-      "cannot use '@execution' together with @isolated(any)",
-      ())
+ERROR(execution_behavior_type_attr_incompatible_with_global_isolation,none,
+      "cannot use '@%0' because function type is isolated to a global actor %1",
+      (StringRef, Type))
+
+ERROR(execution_behavior_type_attr_incompatible_with_isolated_param,none,
+      "cannot use '@%0' together with an isolated parameter",
+      (StringRef))
+
+ERROR(execution_behavior_type_attr_incompatible_with_isolated_any,none,
+      "cannot use '@%0' together with @isolated(any)",
+      (StringRef))
 
 ERROR(invalid_function_conversion_with_non_sendable,none,
       "cannot convert %0 to %1 because crossing of an isolation boundary "

lib/Sema/TypeCheckAttr.cpp

@@ -208,7 +208,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     }
 
     if (!decl->isAsync()) {
-      diagnoseAndRemoveAttr(attr, diag::attr_execution_only_on_async, decl);
+      diagnoseAndRemoveAttr(attr, diag::execution_behavior_only_on_async, attr,
+                            decl);
       return;
     }
 
@@ -224,17 +225,18 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
       // isolated parameters affect isolation of the function itself
       if (isa<IsolatedTypeRepr>(repr)) {
         diagnoseAndRemoveAttr(
-            attr, diag::attr_execution_incompatible_isolated_parameter, decl,
-            P);
+            attr, diag::execution_behavior_incompatible_isolated_parameter,
+            attr, decl, P);
         return;
       }
 
       if (auto *attrType = dyn_cast<AttributedTypeRepr>(repr)) {
         if (attrType->has(TypeAttrKind::Isolated)) {
           diagnoseAndRemoveAttr(
               attr,
-              diag::attr_execution_incompatible_dynamically_isolated_parameter,
-              decl, P);
+              diag::
+                  execution_behavior_incompatible_dynamically_isolated_parameter,
+              attr, decl, P);
           return;
         }
       }
@@ -8154,7 +8156,7 @@ class ClosureAttributeChecker
         closure->getAsyncLoc().isInvalid()) {
       ctx.Diags
           .diagnose(attr->getLocation(),
-                    diag::attr_execution_only_on_async_closure)
+                    diag::execution_behavior_only_on_async_closure, attr)
           .fixItRemove(attr->getRangeWithAt());
       attr->setInvalid();
     }
@@ -8163,8 +8165,8 @@ class ClosureAttributeChecker
       ctx.Diags
           .diagnose(
               attr->getLocation(),
-              diag::attr_execution_type_attr_incompatible_with_global_isolation,
-              actorType)
+              diag::execution_behavior_attr_incompatible_with_global_isolation,
+              attr, actorType)
           .fixItRemove(attr->getRangeWithAt());
       attr->setInvalid();
     }
@@ -8174,7 +8176,8 @@ class ClosureAttributeChecker
         ctx.Diags
             .diagnose(
                 attr->getLocation(),
-                diag::attr_execution_type_attr_incompatible_with_isolated_param)
+                diag::execution_behavior_attr_incompatible_with_isolated_param,
+                attr)
             .fixItRemove(attr->getRangeWithAt());
         attr->setInvalid();
       }

lib/Sema/TypeCheckType.cpp

@@ -4198,7 +4198,8 @@ NeverNullType TypeResolver::resolveASTFunctionType(
   if (auto executionAttr = claim<ExecutionTypeAttr>(attrs)) {
     if (!repr->isAsync()) {
       diagnoseInvalid(repr, executionAttr->getAtLoc(),
-                      diag::attr_execution_type_attr_only_on_async);
+                      diag::execution_behavior_type_attr_only_on_async,
+                      executionAttr->getAttrName());
     }
 
     switch (isolation.getKind()) {
@@ -4208,20 +4209,22 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     case FunctionTypeIsolation::Kind::GlobalActor:
       diagnoseInvalid(
           repr, executionAttr->getAtLoc(),
-          diag::attr_execution_type_attr_incompatible_with_global_isolation,
-          isolation.getGlobalActorType());
+          diag::execution_behavior_type_attr_incompatible_with_global_isolation,
+          executionAttr->getAttrName(), isolation.getGlobalActorType());
       break;
 
     case FunctionTypeIsolation::Kind::Parameter:
       diagnoseInvalid(
           repr, executionAttr->getAtLoc(),
-          diag::attr_execution_type_attr_incompatible_with_isolated_param);
+          diag::execution_behavior_type_attr_incompatible_with_isolated_param,
+          executionAttr->getAttrName());
       break;
 
     case FunctionTypeIsolation::Kind::Erased:
       diagnoseInvalid(
           repr, executionAttr->getAtLoc(),
-          diag::attr_execution_type_attr_incompatible_with_isolated_any);
+          diag::execution_behavior_type_attr_incompatible_with_isolated_any,
+          executionAttr->getAttrName());
       break;
 
     case FunctionTypeIsolation::Kind::NonIsolatedCaller:

test/attr/attr_execution.swift

@@ -17,33 +17,33 @@ do {
 }
 
 @execution(concurrent) func nonAsync1() {}
-// expected-error@-1 {{cannot use '@execution' on non-async global function 'nonAsync1()'}}
+// expected-error@-1 {{cannot use '@execution(concurrent)' on non-async global function 'nonAsync1()'}}
 
 @execution(caller) func nonAsync2() {}
-// expected-error@-1 {{cannot use '@execution' on non-async global function 'nonAsync2()'}}
+// expected-error@-1 {{cannot use '@execution(caller)' on non-async global function 'nonAsync2()'}}
 
 @execution(concurrent) func testGlobal() async {} // Ok
 
 struct Test {
   @execution(concurrent) init() {}
-  // expected-error@-1 {{cannot use '@execution' on non-async initializer 'init()'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on non-async initializer 'init()'}}
 
   @execution(concurrent) init(async: Void) async {}
 
   @execution(concurrent) func member() {}
-  // expected-error@-1 {{cannot use '@execution' on non-async instance method 'member()'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on non-async instance method 'member()'}}
 
   @execution(concurrent) func member() async {} // Ok
 
   @execution(concurrent) var syncP: Int {
-  // expected-error@-1 {{cannot use '@execution' on non-async property 'syncP'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on non-async property 'syncP'}}
     get {}
   }
   @execution(concurrent) var asyncP: Int {
     get async {}
   }
 
-  // expected-error@+1 {{cannot use '@execution' on non-async subscript 'subscript(sync:)'}}
+  // expected-error@+1 {{cannot use '@execution(caller)' on non-async subscript 'subscript(sync:)'}}
   @execution(caller) subscript(sync _: Int) -> Bool {
     @execution(concurrent) get { false }
     // expected-error@-1 {{@execution(concurrent)' attribute cannot be applied to this declaration}}
@@ -72,7 +72,7 @@ do {
 
   protocol P {
     @execution(caller) var syncP: Int { get }
-    // expected-error@-1 {{cannot use '@execution' on non-async property 'syncP'}}
+    // expected-error@-1 {{cannot use '@execution(caller)' on non-async property 'syncP'}}
 
     @execution(caller) var asyncP: Int { get async }
   }
@@ -82,16 +82,16 @@ struct TestAttributeCollisions {
   @execution(concurrent) nonisolated func testNonIsolated() async {}
 
   @execution(concurrent) func test(arg: isolated MainActor) async {}
-  // expected-error@-1 {{cannot use '@execution' on instance method 'test(arg:)' because it has an isolated parameter: 'arg'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on instance method 'test(arg:)' because it has an isolated parameter: 'arg'}}
   @execution(concurrent) subscript(test arg: isolated MainActor) -> Int {
-  // expected-error@-1 {{cannot use '@execution' on subscript 'subscript(test:)' because it has an isolated parameter: 'arg'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on subscript 'subscript(test:)' because it has an isolated parameter: 'arg'}}
     get async {}
   }
 
   @execution(concurrent) func testIsolationAny(arg: @isolated(any) () -> Void) async {}
-  // expected-error@-1 {{cannot use '@execution' on instance method 'testIsolationAny(arg:)' because it has a dynamically isolated parameter: 'arg'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on instance method 'testIsolationAny(arg:)' because it has a dynamically isolated parameter: 'arg'}}
   @execution(concurrent) subscript(testIsolationAny arg: @isolated(any) () -> Void) -> Int {
-  // expected-error@-1 {{cannot use '@execution' on subscript 'subscript(testIsolationAny:)' because it has a dynamically isolated parameter: 'arg'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on subscript 'subscript(testIsolationAny:)' because it has a dynamically isolated parameter: 'arg'}}
     get async {}
   }
 
@@ -102,7 +102,7 @@ struct TestAttributeCollisions {
   @MainActor @execution(caller) func testGlobalActorCaller() async {}
   // expected-warning@-1 {{instance method 'testGlobalActorCaller()' has multiple actor-isolation attributes (@MainActor and @execution(caller))}}
   @execution(caller) func testCaller(arg: isolated MainActor) async {}
-  // expected-error@-1 {{cannot use '@execution' on instance method 'testCaller(arg:)' because it has an isolated parameter: 'arg'}}
+  // expected-error@-1 {{cannot use '@execution(caller)' on instance method 'testCaller(arg:)' because it has an isolated parameter: 'arg'}}
 
   @execution(concurrent) @Sendable func test(_: @Sendable () -> Void, _: sending Int) async {} // Ok
   @execution(caller) @Sendable func testWithSendableCaller(_: @Sendable () -> Void, _: sending Int) async {} // Ok
@@ -129,13 +129,13 @@ _ = { @execution(concurrent) in // Ok
 }
 
 _ = { @MainActor @execution(concurrent) in
-  // expected-error@-1 {{cannot use '@execution' because function type is isolated to a global actor 'MainActor'}}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' because function type is isolated to a global actor 'MainActor'}}
 }
 
 _ = { @execution(concurrent) () -> Int in
-  // expected-error@-1 {{'@execution' on non-async closure}}
+  // expected-error@-1 {{'@execution(concurrent)' on non-async closure}}
 }
 
 _ = { @execution(caller) (x: isolated (any Actor)?) in
-  // expected-error@-1 {{cannot use '@execution' together with an isolated parameter}}
+  // expected-error@-1 {{cannot use '@execution(caller)' together with an isolated parameter}}
 }