[AST/Sema] Support for @concurrent attribute in type context

Author: xedin

include/swift/AST/TypeAttr.def

@@ -68,6 +68,7 @@ TYPE_ATTR(isolated, Isolated)
 SIMPLE_TYPE_ATTR(nonisolated, Nonisolated)
 SIMPLE_TYPE_ATTR(_addressable, Addressable)
 TYPE_ATTR(execution, Execution)
+SIMPLE_TYPE_ATTR(concurrent, Concurrent)
 
 // SIL-specific attributes
 SIMPLE_SIL_TYPE_ATTR(async, Async)

lib/ASTGen/Sources/ASTGen/TypeAttrs.swift

@@ -42,6 +42,7 @@ extension ASTGenVisitor {
       // Simple type attributes.
       case .autoclosure,
         .addressable,
+        .concurrent,
         .escaping,
         .noEscape,
         .noDerivative,

lib/Sema/TypeCheckType.cpp

@@ -4201,11 +4201,11 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     }
   }
 
-  if (auto executionAttr = claim<ExecutionTypeAttr>(attrs)) {
+  auto checkExecutionBehaviorAttribute = [&](TypeAttribute *attr) {
     if (!repr->isAsync()) {
-      diagnoseInvalid(repr, executionAttr->getAtLoc(),
+      diagnoseInvalid(repr, attr->getAttrLoc(),
                       diag::execution_behavior_type_attr_only_on_async,
-                      executionAttr->getAttrName());
+                      attr->getAttrName());
     }
 
     switch (isolation.getKind()) {
@@ -4214,29 +4214,33 @@ NeverNullType TypeResolver::resolveASTFunctionType(
 
     case FunctionTypeIsolation::Kind::GlobalActor:
       diagnoseInvalid(
-          repr, executionAttr->getAtLoc(),
+          repr, attr->getAttrLoc(),
           diag::execution_behavior_type_attr_incompatible_with_global_isolation,
-          executionAttr->getAttrName(), isolation.getGlobalActorType());
+          attr->getAttrName(), isolation.getGlobalActorType());
       break;
 
     case FunctionTypeIsolation::Kind::Parameter:
       diagnoseInvalid(
-          repr, executionAttr->getAtLoc(),
+          repr, attr->getAttrLoc(),
           diag::execution_behavior_type_attr_incompatible_with_isolated_param,
-          executionAttr->getAttrName());
+          attr->getAttrName());
       break;
 
     case FunctionTypeIsolation::Kind::Erased:
       diagnoseInvalid(
-          repr, executionAttr->getAtLoc(),
+          repr, attr->getAttrLoc(),
           diag::execution_behavior_type_attr_incompatible_with_isolated_any,
-          executionAttr->getAttrName());
+          attr->getAttrName());
       break;
 
     case FunctionTypeIsolation::Kind::NonIsolatedCaller:
       llvm_unreachable("cannot happen because multiple @execution attributes "
                        "aren't allowed.");
     }
+  };
+
+  if (auto executionAttr = claim<ExecutionTypeAttr>(attrs)) {
+    checkExecutionBehaviorAttribute(executionAttr);
 
     if (!repr->isInvalid()) {
       switch (executionAttr->getBehavior()) {
@@ -4248,6 +4252,10 @@ NeverNullType TypeResolver::resolveASTFunctionType(
         break;
       }
     }
+  } else if (auto concurrentAttr = claim<ConcurrentTypeAttr>(attrs)) {
+    checkExecutionBehaviorAttribute(concurrentAttr);
+    if (!repr->isInvalid())
+      isolation = FunctionTypeIsolation::forNonIsolated();
   } else {
     if (ctx.LangOpts.getFeatureState(Feature::AsyncCallerExecution)
             .isEnabledForAdoption()) {