[ASTGen] Generate ConventionTypeAttr

E.g. `@convention(c)`

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -2209,6 +2209,14 @@ enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedIsolatedTypeAttrIsolationKind {
   BridgedIsolatedTypeAttrIsolationKind_DynamicIsolation,
 };
 
+SWIFT_NAME("BridgedConventionTypeAttr.createParsed(_:atLoc:nameLoc:parensRange:"
+           "name:nameLoc:witnessMethodProtocol:clangType:clangTypeLoc:)")
+BridgedConventionTypeAttr BridgedConventionTypeAttr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
+    BridgedSourceLoc cKwLoc, BridgedSourceRange cParens, BridgedStringRef cName,
+    BridgedSourceLoc cNameLoc, BridgedDeclNameRef cWitnessMethodProtocol,
+    BridgedStringRef cClangType, BridgedSourceLoc cClangTypeLoc);
+
 SWIFT_NAME("BridgedIsolatedTypeAttr.createParsed(_:atLoc:nameLoc:lpLoc:"
            "isolationKindLoc:isolationKind:rpLoc:)")
 BridgedIsolatedTypeAttr BridgedIsolatedTypeAttr_createParsed(

lib/AST/Bridging/TypeAttributeBridging.cpp

@@ -84,6 +84,18 @@ BridgedTypeAttribute BridgedTypeAttribute_createSimple(
                                      cAtLoc.unbridged(), cNameLoc.unbridged());
 }
 
+BridgedConventionTypeAttr BridgedConventionTypeAttr_createParsed(
+    BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
+    BridgedSourceLoc cKwLoc, BridgedSourceRange cParens, BridgedStringRef cName,
+    BridgedSourceLoc cNameLoc, BridgedDeclNameRef cWitnessMethodProtocol,
+    BridgedStringRef cClangType, BridgedSourceLoc cClangTypeLoc) {
+  return new (cContext.unbridged()) ConventionTypeAttr(
+      cAtLoc.unbridged(), cKwLoc.unbridged(), cParens.unbridged(),
+      {cName.unbridged(), cNameLoc.unbridged()},
+      cWitnessMethodProtocol.unbridged(),
+      {cClangType.unbridged(), cClangTypeLoc.unbridged()});
+}
+
 BridgedIsolatedTypeAttr BridgedIsolatedTypeAttr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
     BridgedSourceLoc cNameLoc, BridgedSourceLoc cLPLoc,

lib/ASTGen/Sources/ASTGen/TypeAttrs.swift

@@ -84,6 +84,7 @@ extension ASTGenVisitor {
       case .differentiable:
         fatalError("unimplemented")
       case .convention:
+        return self.generateConventionTypeAttr(attribute: node)?.asTypeAttribute
         fatalError("unimplemented")
       case .opaqueReturnTypeOf:
         fatalError("unimplemented")
@@ -146,6 +147,39 @@ extension ASTGenVisitor {
     )
   }
 
+  func generateConventionTypeAttr(attribute node: AttributeSyntax) -> BridgedConventionTypeAttr? {
+    // FIXME: This don't need custom attribute arguments syntax.
+    // FIXME: Support 'witness_method' argument.
+    guard let args = node.arguments?.as(ConventionAttributeArgumentsSyntax.self) else {
+      // TODO: Diangose.
+      return nil
+    }
+    
+    let cTypeName: BridgedStringRef?
+    let cTypeNameLoc: BridgedSourceLoc?
+    if let ctypeString = args.cTypeString {
+      cTypeName = self.generateStringLiteralTextIfNotInterpolated(expr: ctypeString)
+      cTypeNameLoc = cTypeName != nil ? self.generateSourceLoc(ctypeString) : nil
+    } else {
+      cTypeName = nil
+      cTypeNameLoc = nil
+    }
+    
+    let witnessMethodProtocol: BridgedDeclNameRef = BridgedDeclNameRef()
+    
+    return .createParsed(
+      self.ctx,
+      atLoc: self.generateSourceLoc(node.atSign),
+      nameLoc: self.generateSourceLoc(node.attributeName),
+      parensRange: self.generateSourceRange(start: node.leftParen!, end: node.rightParen!),
+      name: ctx.allocateCopy(string: args.conventionLabel.rawText.bridged),
+      nameLoc: self.generateSourceLoc(args.conventionLabel),
+      witnessMethodProtocol: witnessMethodProtocol,
+      clangType: cTypeName ?? BridgedStringRef(),
+      clangTypeLoc: cTypeNameLoc ?? BridgedSourceLoc()
+    )
+  }
+  
   func generateIsolatedTypeAttr(attribute node: AttributeSyntax) -> BridgedIsolatedTypeAttr? {
     guard case .argumentList(let isolatedArgs) = node.arguments,
           isolatedArgs.count == 1,

test/ASTGen/attrs.swift

@@ -190,3 +190,5 @@ do {
     @execution(concurrent) func testMember() async {} // Ok
   }
 }
+
+func testConvention(fn: @convention(c) (Int) -> Int) {}