[Sema] Impliment initial validation of @execution(concurrent) attribute

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -8211,5 +8211,32 @@ ERROR(attr_abi_incompatible_with_silgen_name,none,
       "the same purpose",
       (DescriptiveDeclKind))
 
+//===----------------------------------------------------------------------===//
+// MARK: @execution Attribute
+//===----------------------------------------------------------------------===//
+ERROR(attr_execution_concurrent_only_on_async,none,
+      "cannot use '@execution(concurrent)' on non-async %kind0",
+      (ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_with_global_actor,none,
+      "cannot use '@execution(concurrent)' on %kind0 isolated to global actor %1",
+      (ValueDecl *, ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_isolated_parameter,none,
+      "cannot use '@execution(concurrent)' on %kind0 because it has "
+      "an isolated parameter: %1",
+      (ValueDecl *, ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_dynamically_isolated_parameter,none,
+      "cannot use '@execution(concurrent)' on %kind0 because it has "
+      "a dynamically isolated parameter: %1",
+      (ValueDecl *, ValueDecl *))
+
+ERROR(attr_execution_concurrent_incompatible_with_nonisolated,none,
+      "cannot use '@execution(concurrent)' and 'nonisolated' on the same %0 "
+      "because they serve the same purpose",
+      (ValueDecl *))
+
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/Sema/TypeCheckAttr.cpp

@@ -253,6 +253,80 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   }
 
 public:
+  void visitExecutionAttr(ExecutionAttr *attr) {
+    auto *F = dyn_cast<FuncDecl>(D);
+    if (!F)
+      return;
+
+    if (!F->hasAsync()) {
+      diagnoseAndRemoveAttr(attr, diag::attr_execution_concurrent_only_on_async,
+                            F);
+      return;
+    }
+
+    // Checks based on explicit attributes, inferred ones would
+    // have to be handled during actor isolation inference.
+
+    switch (attr->getBehavior()) {
+    case ExecutionKind::Concurrent: {
+      // 'concurrent' doesn't work with explicit `nonisolated`
+      if (F->hasExplicitIsolationAttribute()) {
+        if (F->getAttrs().hasAttribute<NonisolatedAttr>()) {
+          diagnoseAndRemoveAttr(
+              attr,
+              diag::attr_execution_concurrent_incompatible_with_nonisolated, F);
+          return;
+        }
+
+        if (auto globalActor = F->getGlobalActorAttr()) {
+          diagnoseAndRemoveAttr(
+              attr,
+              diag::attr_execution_concurrent_incompatible_with_global_actor, F,
+              globalActor->second);
+          return;
+        }
+      }
+
+      auto parameters = F->getParameters();
+      if (!parameters)
+        return;
+
+      for (auto *P : *parameters) {
+        auto *repr = P->getTypeRepr();
+        if (!repr)
+          continue;
+
+        // isolated parameters affect isolation of the function itself
+        if (isa<IsolatedTypeRepr>(repr)) {
+          diagnoseAndRemoveAttr(
+              attr,
+              diag::attr_execution_concurrent_incompatible_isolated_parameter,
+              F, P);
+          return;
+        }
+
+        if (auto *attrType = dyn_cast<AttributedTypeRepr>(repr)) {
+          if (attrType->has(TypeAttrKind::Isolated)) {
+            diagnoseAndRemoveAttr(
+                attr,
+                diag::
+                    attr_execution_concurrent_incompatible_dynamically_isolated_parameter,
+                F, P);
+            return;
+          }
+        }
+      }
+
+      break;
+    }
+
+    case ExecutionKind::Caller: {
+      // no restrictions for now.
+      break;
+    }
+    }
+  }
+
   void visitABIAttr(ABIAttr *attr) {
     Decl *AD = attr->abiDecl;
     if (isa<VarDecl>(D) && isa<PatternBindingDecl>(AD)) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1593,6 +1593,7 @@ namespace  {
     UNINTERESTING_ATTR(DynamicCallable)
     UNINTERESTING_ATTR(DynamicMemberLookup)
     UNINTERESTING_ATTR(SILGenName)
+    UNINTERESTING_ATTR(Execution)
     UNINTERESTING_ATTR(Exported)
     UNINTERESTING_ATTR(ForbidSerializingReference)
     UNINTERESTING_ATTR(GKInspectable)

test/attr/attr_execution.swift

@@ -0,0 +1,57 @@
+// RUN: %target-typecheck-verify-swift -target %target-swift-5.1-abi-triple -enable-experimental-feature NonIsolatedAsyncInheritsIsolationFromContext
+
+// REQUIRES: concurrency
+// REQUIRES: swift_feature_NonIsolatedAsyncInheritsIsolationFromContext
+
+@execution(something) func invalidAttr() async {} // expected-error {{unknown option 'something' for attribute 'execution'}}
+
+@execution(concurrent) @execution(caller) func mutipleAttrs() async {}
+// expected-error@-1 {{duplicate attribute}} expected-note@-1 {{attribute already specified here}}
+
+@execution(concurrent) func nonAsync1() {}
+// expected-error@-1 {{cannot use '@execution(concurrent)' on non-async global function 'nonAsync1()'}}
+
+@execution(caller) func nonAsync2() {}
+// expected-error@-1 {{cannot use '@execution(concurrent)' on non-async global function 'nonAsync2()'}}
+
+@execution(concurrent) func testGlobal() async {} // Ok
+
+struct Test {
+  @execution(concurrent) init() {}
+  // expected-error@-1 {{@execution(concurrent) may only be used on 'func' declarations}}
+
+  @execution(concurrent) func member() {}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on non-async instance method 'member()'}}
+
+  @execution(concurrent) func member() async {} // Ok
+
+  // expected-error@+1 {{@execution(caller) may only be used on 'func' declarations}}
+  @execution(caller) subscript(a: Int) -> Bool {
+    get { false }
+    @execution(concurrent) set { }
+    // expected-error@-1 {{@execution(concurrent) may only be used on 'func' declarations}}
+  }
+
+  @execution(caller) var x: Int
+  // expected-error@-1 {{@execution(caller) may only be used on 'func' declarations}}
+}
+
+do {
+  @execution(caller) func local() async {} // Ok
+}
+
+struct TestAttributeCollisions {
+  @execution(concurrent) nonisolated func testNonIsolated() async {}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' and 'nonisolated' on the same 'testNonIsolated()' because they serve the same purpose}}
+
+  @execution(concurrent) func test(arg: isolated MainActor) async {}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on instance method 'test(arg:)' because it has an isolated parameter: 'arg'}}
+
+  @execution(concurrent) func testIsolationAny(arg: @isolated(any) () -> Void) async {}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on instance method 'testIsolationAny(arg:)' because it has a dynamically isolated parameter: 'arg'}}
+
+  @MainActor @execution(concurrent) func testGlobalActor() async {}
+  // expected-error@-1 {{cannot use '@execution(concurrent)' on instance method 'testGlobalActor()' isolated to global actor 'MainActor'}}
+
+  @execution(concurrent) @Sendable func test(_: @Sendable () -> Void, _: sending Int) async {} // Ok
+}