[ASTGen] Handle simple type attributes.

Bridge the simple type attributes like `@autoclosure` into an
`AttributedTypeRepr`. We don't validate the arguments, and we don't
handle more complicated attributes like `@convention(c)` just yet.

Author: DougGregor

include/swift/AST/CASTBridging.h

@@ -123,6 +123,59 @@ typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedAttributedTypeSpecifier : long
   BridgedAttributedTypeSpecifierIsolated,
 } BridgedAttributedTypeSpecifier;
 
+
+// Bridged type attribute kinds, which mirror TypeAttrKind exactly.
+typedef enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedTypeAttrKind : long {
+  BridgedTypeAttrKind_autoclosure,
+  BridgedTypeAttrKind_convention,
+  BridgedTypeAttrKind_noescape,
+  BridgedTypeAttrKind_escaping,
+  BridgedTypeAttrKind_differentiable,
+  BridgedTypeAttrKind_noDerivative,
+  BridgedTypeAttrKind_async,
+  BridgedTypeAttrKind_Sendable,
+  BridgedTypeAttrKind_unchecked,
+  BridgedTypeAttrKind__local,
+  BridgedTypeAttrKind__noMetadata,
+  BridgedTypeAttrKind__opaqueReturnTypeOf,
+  BridgedTypeAttrKind_block_storage,
+  BridgedTypeAttrKind_box,
+  BridgedTypeAttrKind_dynamic_self,
+  BridgedTypeAttrKind_sil_weak,
+  BridgedTypeAttrKind_sil_unowned,
+  BridgedTypeAttrKind_sil_unmanaged,
+  BridgedTypeAttrKind_error,
+  BridgedTypeAttrKind_out,
+  BridgedTypeAttrKind_direct,
+  BridgedTypeAttrKind_in,
+  BridgedTypeAttrKind_inout,
+  BridgedTypeAttrKind_inout_aliasable,
+  BridgedTypeAttrKind_in_guaranteed,
+  BridgedTypeAttrKind_in_constant,
+  BridgedTypeAttrKind_pack_owned,
+  BridgedTypeAttrKind_pack_guaranteed,
+  BridgedTypeAttrKind_pack_inout,
+  BridgedTypeAttrKind_pack_out,
+  BridgedTypeAttrKind_owned,
+  BridgedTypeAttrKind_unowned_inner_pointer,
+  BridgedTypeAttrKind_guaranteed,
+  BridgedTypeAttrKind_autoreleased,
+  BridgedTypeAttrKind_callee_owned,
+  BridgedTypeAttrKind_callee_guaranteed,
+  BridgedTypeAttrKind_objc_metatype,
+  BridgedTypeAttrKind_opened,
+  BridgedTypeAttrKind_pack_element,
+  BridgedTypeAttrKind_pseudogeneric,
+  BridgedTypeAttrKind_yields,
+  BridgedTypeAttrKind_yield_once,
+  BridgedTypeAttrKind_yield_many,
+  BridgedTypeAttrKind_captures_generics,
+  BridgedTypeAttrKind_moveOnly,
+  BridgedTypeAttrKind_thin,
+  BridgedTypeAttrKind_thick,
+  BridgedTypeAttrKind_Count
+} BridgedTypeAttrKind;
+
 #ifdef __cplusplus
 extern "C" {
 
@@ -272,6 +325,16 @@ void *ImplicitlyUnwrappedOptionalTypeRepr_create(void *ctx, void *base,
                                                  void *exclamationLoc);
 void *MetatypeTypeRepr_create(void *ctx, void *baseType, void *typeLoc);
 void *ProtocolTypeRepr_create(void *ctx, void *baseType, void *protoLoc);
+
+BridgedTypeAttrKind getBridgedTypeAttrKindFromString(
+    const unsigned char * _Nullable str, long len);
+
+typedef void *BridgedTypeAttributes;
+BridgedTypeAttributes BridgedTypeAttributes_create(void);
+void BridgedTypeAttributes_addSimpleAttr(
+    BridgedTypeAttributes typeAttributes, BridgedTypeAttrKind kind, void *atLoc, void *attrLoc);
+void *AttributedTypeRepr_create(void *ctx, void *base, BridgedTypeAttributes typeAttributes);
+
 void *AttributedTypeSpecifierRepr_create(
     void *ctx, void *base, BridgedAttributedTypeSpecifier specifier, void *specifierLoc);
 void *VarargTypeRepr_create(void *ctx, void *base, void *ellipsisLocPtr);

lib/AST/CASTBridging.cpp

@@ -490,6 +490,56 @@ void *PackExpansionTypeRepr_create(void *ctx, void *base, void *repeatLoc) {
       getSourceLocFromPointer(repeatLoc), (TypeRepr *)base);
 }
 
+static BridgedTypeAttrKind bridgeTypeAttrKind(TypeAttrKind kind) {
+  switch (kind) {
+#define TYPE_ATTR(X) case TAK_##X: return BridgedTypeAttrKind_##X;
+#include "swift/AST/Attr.def"
+    case TAK_Count: return BridgedTypeAttrKind_Count;
+  }
+}
+
+static TypeAttrKind bridgeTypeAttrKind(BridgedTypeAttrKind kind) {
+  switch (kind) {
+#define TYPE_ATTR(X) case BridgedTypeAttrKind_##X: return TAK_##X;
+#include "swift/AST/Attr.def"
+    case BridgedTypeAttrKind_Count: return TAK_Count;
+  }
+}
+
+BridgedTypeAttrKind getBridgedTypeAttrKindFromString(
+    const unsigned char *str, intptr_t len) {
+  return bridgeTypeAttrKind(
+      TypeAttributes::getAttrKindFromString(StringRef((const char *)str, len)));
+}
+
+BridgedTypeAttributes BridgedTypeAttributes_create() {
+  return new TypeAttributes();
+}
+
+void BridgedTypeAttributes_addSimpleAttr(
+    BridgedTypeAttributes typeAttributesPtr, BridgedTypeAttrKind kind,
+    void *atLoc, void *attrLoc
+) {
+  TypeAttributes *typeAttributes = (TypeAttributes *)typeAttributesPtr;
+  typeAttributes->setAttr(
+      bridgeTypeAttrKind(kind), getSourceLocFromPointer(attrLoc));
+  if (typeAttributes->AtLoc.isInvalid())
+    typeAttributes->AtLoc = getSourceLocFromPointer(atLoc);
+}
+
+void *AttributedTypeRepr_create(
+    void *ctx, void *base, BridgedTypeAttributes typeAttributesPtr) {
+  TypeAttributes *typeAttributes = (TypeAttributes *)typeAttributesPtr;
+  if (typeAttributes->empty())
+    return base;
+
+  ASTContext &Context = *static_cast<ASTContext *>(ctx);
+  auto attributedType =
+    new (Context) AttributedTypeRepr(*typeAttributes, (TypeRepr *)base);
+  delete typeAttributes;
+  return attributedType;
+}
+
 void *AttributedTypeSpecifierRepr_create(
     void *ctx, void *base, BridgedAttributedTypeSpecifier specifier, void *specifierLoc
 ) {

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -187,7 +187,54 @@ extension ASTGenVisitor {
       type = .type(AttributedTypeSpecifierRepr_create(self.ctx, type.rawValue, kind, specifierLoc))
     }
 
-    // FIXME: Respect the attributes
+    // Handle type attributes.
+    if let attributes = node.attributes {
+      let typeAttributes = BridgedTypeAttributes_create()
+      for attributeElt in attributes {
+        // FIXME: Ignoring #ifs entirely. We want to provide a filtered view,
+        // but we don't have that ability right now.
+        guard case let .attribute(attribute) = attributeElt else {
+          continue
+        }
+
+        // Only handle simple attribute names right now.
+        guard let identType = attribute.attributeName.as(SimpleTypeIdentifierSyntax.self) else {
+          continue
+        }
+
+        let nameSyntax = identType.name
+        var name = nameSyntax.text
+        let typeAttrKind = name.withUTF8 { buf in
+          getBridgedTypeAttrKindFromString(buf.baseAddress, buf.count)
+        }
+        let atLoc = self.base.advanced(by: attribute.atSignToken.position.utf8Offset).raw
+        let attrLoc = self.base.advanced(by: nameSyntax.position.utf8Offset).raw
+        switch typeAttrKind {
+          // SIL attributes
+          // FIXME: Diagnose if not in SIL mode? Or should that move to the
+          // type checker?
+          case .out, .in, .owned, .unowned_inner_pointer, .guaranteed,
+               .autoreleased, .callee_owned, .callee_guaranteed, .objc_metatype,
+               .sil_weak, .sil_unowned, .inout, .block_storage, .box,
+               .dynamic_self, .sil_unmanaged, .error, .direct, .inout_aliasable,
+               .in_guaranteed, .in_constant, .captures_generics, .moveOnly:
+            fallthrough
+
+          case .autoclosure, .escaping, .noescape, .noDerivative, .async,
+            .sendable, .unchecked, ._local, ._noMetadata, .pack_owned,
+            .pack_guaranteed, .pack_inout, .pack_out, .pseudogeneric,
+            .yields, .yield_once, .yield_many, .thin, .thick, .count:
+            BridgedTypeAttributes_addSimpleAttr(typeAttributes, typeAttrKind, atLoc, attrLoc)
+
+          case .opened, .pack_element, .differentiable, .convention,
+            ._opaqueReturnTypeOf:
+            // FIXME: These require more complicated checks
+            break
+        }
+      }
+
+      type = .type(AttributedTypeRepr_create(self.ctx, type.rawValue, typeAttributes))
+    }
 
     return type
   }

test/ASTGen/types.swift

@@ -21,3 +21,10 @@ typealias VAFunc = (Int, Int...) -> Int
 func testVAFunc(a: Int, f: VAFunc) {
   _ = f(a, a, a, a, a)
 }
+
+func test12(_ producer: @escaping @autoclosure () -> Int) {
+  _ = producer()
+}
+func test12a(i: Int) {
+  test12(i)
+}