[AST] Add @execution(concurrent | caller) type attribute

Author: xedin

include/swift/AST/ASTBridging.h

@@ -1984,6 +1984,18 @@ BridgedTypeAttribute BridgedTypeAttribute_createIsolated(
     BridgedSourceLoc cLPLoc, BridgedSourceLoc cIsolationLoc,
     BridgedIsolatedTypeAttrIsolationKind cIsolation, BridgedSourceLoc cRPLoc);
 
+enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedExecutionTypeAttrExecutionKind {
+  BridgedExecutionTypeAttrExecutionKind_Concurrent,
+  BridgedExecutionTypeAttrExecutionKind_Caller
+};
+
+SWIFT_NAME("BridgedTypeAttribute.createExecution(_:atLoc:nameLoc:lpLoc:behaviorLoc:behavior:rpLoc:)")
+BridgedTypeAttribute BridgedTypeAttribute_createExecution(
+    BridgedASTContext cContext,
+    BridgedSourceLoc cAtLoc, BridgedSourceLoc cNameLoc,
+    BridgedSourceLoc cLPLoc, BridgedSourceLoc cBehaviorLoc,
+    BridgedExecutionTypeAttrExecutionKind behavior, BridgedSourceLoc cRPLoc);
+
 //===----------------------------------------------------------------------===//
 // MARK: TypeReprs
 //===----------------------------------------------------------------------===//

include/swift/AST/Attr.h

@@ -3475,6 +3475,10 @@ class alignas(1 << AttrAlignInBits) TypeAttribute
     SWIFT_INLINE_BITFIELD_FULL(IsolatedTypeAttr, TypeAttribute, 8,
       Kind : 8
     );
+
+    SWIFT_INLINE_BITFIELD_FULL(ExecutionTypeAttr, TypeAttribute, 8,
+      Behavior : 8
+    );
   } Bits;
   // clang-format on
 
@@ -3740,6 +3744,28 @@ class IsolatedTypeAttr : public SimpleTypeAttrWithArgs<TypeAttrKind::Isolated> {
   void printImpl(ASTPrinter &printer, const PrintOptions &options) const;
 };
 
+/// The @execution function type attribute.
+class ExecutionTypeAttr : public SimpleTypeAttrWithArgs<TypeAttrKind::Execution> {
+  SourceLoc BehaviorLoc;
+
+public:
+  ExecutionTypeAttr(SourceLoc atLoc, SourceLoc kwLoc, SourceRange parensRange,
+                    Located<ExecutionKind> behavior)
+      : SimpleTypeAttr(atLoc, kwLoc, parensRange), BehaviorLoc(behavior.Loc) {
+    Bits.ExecutionTypeAttr.Behavior = uint8_t(behavior.Item);
+  }
+
+  ExecutionKind getBehavior() const {
+    return ExecutionKind(Bits.ExecutionTypeAttr.Behavior);
+  }
+
+  SourceLoc getBehaviorLoc() const {
+    return BehaviorLoc;
+  }
+
+  void printImpl(ASTPrinter &printer, const PrintOptions &options) const;
+};
+
 using TypeOrCustomAttr =
   llvm::PointerUnion<CustomAttr*, TypeAttribute*>;
 

include/swift/AST/TypeAttr.def

@@ -66,6 +66,7 @@ SIMPLE_TYPE_ATTR(_noMetadata, NoMetadata)
 TYPE_ATTR(_opaqueReturnTypeOf, OpaqueReturnTypeOf)
 TYPE_ATTR(isolated, Isolated)
 SIMPLE_TYPE_ATTR(_addressable, Addressable)
+TYPE_ATTR(execution, Execution)
 
 // SIL-specific attributes
 SIMPLE_SIL_TYPE_ATTR(async, Async)

lib/AST/Attr.cpp

@@ -303,6 +303,23 @@ void IsolatedTypeAttr::printImpl(ASTPrinter &printer,
   printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
 }
 
+void ExecutionTypeAttr::printImpl(ASTPrinter &printer,
+                                  const PrintOptions &options) const {
+  printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
+  printer.printAttrName("@execution");
+  printer << "(";
+  switch (getBehavior()) {
+  case ExecutionKind::Concurrent:
+    printer << "concurrent";
+    break;
+  case ExecutionKind::Caller:
+    printer << "caller";
+    break;
+  }
+  printer << ")";
+  printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
+}
+
 /// Given a name like "inline", return the decl attribute ID that corresponds
 /// to it.  Note that this is a many-to-one mapping, and that the identifier
 /// passed in may only be the first portion of the attribute (e.g. in the case

lib/AST/Bridging/TypeAttributeBridging.cpp

@@ -91,3 +91,23 @@ BridgedTypeAttribute BridgedTypeAttribute_createIsolated(
                        {cLPLoc.unbridged(), cRPLoc.unbridged()},
                        {isolationKind, cIsolationLoc.unbridged()});
 }
+
+BridgedTypeAttribute BridgedTypeAttribute_createExecution(
+    BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
+    BridgedSourceLoc cNameLoc, BridgedSourceLoc cLPLoc,
+    BridgedSourceLoc cBehaviorLoc,
+    BridgedExecutionTypeAttrExecutionKind behavior, BridgedSourceLoc cRPLoc) {
+  auto behaviorKind = [=] {
+    switch (behavior) {
+    case BridgedExecutionTypeAttrExecutionKind_Concurrent:
+      return ExecutionKind::Concurrent;
+    case BridgedExecutionTypeAttrExecutionKind_Caller:
+      return ExecutionKind::Caller;
+    }
+    llvm_unreachable("bad kind");
+  }();
+  return new (cContext.unbridged())
+      ExecutionTypeAttr(cAtLoc.unbridged(), cNameLoc.unbridged(),
+                        {cLPLoc.unbridged(), cRPLoc.unbridged()},
+                        {behaviorKind, cBehaviorLoc.unbridged()});
+}

lib/ASTGen/Sources/ASTGen/TypeAttrs.swift

@@ -91,6 +91,9 @@ extension ASTGenVisitor {
       case .isolated:
         return self.generateIsolatedTypeAttr(attribute: node)
 
+      case .execution:
+        return self.generateExecutionTypeAttr(attribute: node)
+
       // SIL type attributes are not supported.
       case .autoreleased,
         .blockStorage,
@@ -173,4 +176,35 @@ extension ASTGenVisitor {
       isolationKind: isolationKind,
       rpLoc: self.generateSourceLoc(node.rightParen!))
   }
+
+  func generateExecutionTypeAttr(attribute node: AttributeSyntax) -> BridgedTypeAttribute? {
+    guard case .argumentList(let executionArgs) = node.arguments,
+          executionArgs.count == 1,
+          let labelArg = executionArgs.first,
+          labelArg.label == nil,
+          let behaviorExpr = labelArg.expression.as(DeclReferenceExprSyntax.self),
+          behaviorExpr.argumentNames == nil
+    else {
+      // TODO: Diagnose.
+      return nil
+    }
+
+    var behavior: BridgedExecutionTypeAttrExecutionKind
+    switch behaviorExpr.baseName {
+    case "concurrent": behavior = .concurrent
+    case "caller": behavior = .caller
+    default:
+      // TODO: Diagnose.
+      return nil
+    }
+
+    return BridgedTypeAttribute.createExecution(
+      self.ctx,
+      atLoc: self.generateSourceLoc(node.atSign),
+      nameLoc: self.generateSourceLoc(node.attributeName),
+      lpLoc: self.generateSourceLoc(node.leftParen!),
+      behaviorLoc: self.generateSourceLoc(behaviorExpr.baseName),
+      behavior: behavior,
+      rpLoc: self.generateSourceLoc(node.rightParen!))
+  }
 }