[ASTGen] Generate closure signatures

Still TODO:
* Capture list
* Anonymous parameters

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -45,6 +45,7 @@ class DiagnosticEngine;
 class Identifier;
 class IfConfigClauseRangeInfo;
 struct LabeledStmtInfo;
+enum class ParamSpecifier : uint8_t;
 class ProtocolConformanceRef;
 class RegexLiteralPatternFeature;
 class RegexLiteralPatternFeatureKind;
@@ -526,6 +527,10 @@ SWIFT_NAME("getter:BridgedPatternBindingInitializer.asDeclContext(self:)")
 BridgedDeclContext BridgedPatternBindingInitializer_asDeclContext(
     BridgedPatternBindingInitializer cInit);
 
+SWIFT_NAME("getter:BridgedClosureExpr.asDeclContext(self:)")
+BridgedDeclContext
+BridgedClosureExpr_asDeclContext(BridgedClosureExpr cClosure);
+
 //===----------------------------------------------------------------------===//
 // MARK: DeclAttributes
 //===----------------------------------------------------------------------===//
@@ -852,6 +857,24 @@ BridgedParamDecl BridgedParamDecl_createParsed(
     BridgedSourceLoc cParamNameLoc, BridgedNullableTypeRepr type,
     BridgedNullableExpr defaultValue);
 
+/// The various spellings of ownership modifier that can be used in source.
+enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedParamSpecifier {
+  BridgedParamSpecifierDefault,
+  BridgedParamSpecifierInOut,
+  BridgedParamSpecifierBorrowing,
+  BridgedParamSpecifierConsuming,
+  BridgedParamSpecifierLegacyShared,
+  BridgedParamSpecifierLegacyOwned,
+  BridgedParamSpecifierImplicitlyCopyableConsuming,
+};
+
+BRIDGED_INLINE swift::ParamSpecifier unbridge(BridgedParamSpecifier kind);
+
+SWIFT_NAME("BridgedParamDecl.setSpecifier(self:_:)")
+BRIDGED_INLINE void
+BridgedParamDecl_setSpecifier(BridgedParamDecl cDecl,
+                              BridgedParamSpecifier cSpecifier);
+
 SWIFT_NAME("BridgedConstructorDecl.setParsedBody(self:_:)")
 void BridgedConstructorDecl_setParsedBody(BridgedConstructorDecl decl,
                                           BridgedBraceStmt body);
@@ -1230,10 +1253,28 @@ BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext,
                                              BridgedExpr fn,
                                              BridgedArgumentList args);
 
-SWIFT_NAME("BridgedClosureExpr.createParsed(_:declContext:parameterList:body:)")
+SWIFT_NAME("BridgedClosureExpr.createParsed(_:declContext:attributes:"
+           "bracketRange:capturedSelfDecl:parameterList:asyncLoc:throwsLoc:"
+           "thrownType:arrowLoc:explicitResultType:inLoc:)")
 BridgedClosureExpr BridgedClosureExpr_createParsed(
     BridgedASTContext cContext, BridgedDeclContext cDeclContext,
-    BridgedParameterList cParamList, BridgedBraceStmt body);
+    BridgedDeclAttributes cAttributes, BridgedSourceRange cBracketRange,
+    BridgedNullableVarDecl cCapturedSelfDecl,
+    BridgedNullableParameterList cParameterList, BridgedSourceLoc cAsyncLoc,
+    BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr cThrownType,
+    BridgedSourceLoc cArrowLoc, BridgedNullableTypeRepr cExplicitResultType,
+    BridgedSourceLoc cInLoc);
+
+SWIFT_NAME("BridgedClosureExpr.setParameterList(self:_:)")
+void BridgedClosureExpr_setParameterList(BridgedClosureExpr cClosure,
+                                         BridgedParameterList cParams);
+
+SWIFT_NAME("BridgedClosureExpr.setHasAnonymousClosureVars(self:)")
+void BridgedClosureExpr_setHasAnonymousClosureVars(BridgedClosureExpr cClosure);
+
+SWIFT_NAME("BridgedClosureExpr.setBody(self:_:)")
+void BridgedClosureExpr_setBody(BridgedClosureExpr cClosure,
+                                BridgedBraceStmt cBody);
 
 SWIFT_NAME("BridgedCoerceExpr.createParsed(_:asLoc:type:)")
 BridgedCoerceExpr BridgedCoerceExpr_createParsed(BridgedASTContext cContext,

include/swift/AST/ASTBridgingImpl.h

@@ -213,6 +213,31 @@ swift::DeclAttributes BridgedDeclAttributes::unbridged() const {
   return attrs;
 }
 
+//===----------------------------------------------------------------------===//
+// MARK: BridgedParamDecl
+//===----------------------------------------------------------------------===//
+
+swift::ParamSpecifier unbridge(BridgedParamSpecifier specifier) {
+  switch (specifier) {
+#define CASE(ID)                                                               \
+  case BridgedParamSpecifier##ID:                                              \
+    return swift::ParamSpecifier::ID;
+    CASE(Default)
+    CASE(InOut)
+    CASE(Borrowing)
+    CASE(Consuming)
+    CASE(LegacyShared)
+    CASE(LegacyOwned)
+    CASE(ImplicitlyCopyableConsuming)
+#undef CASE
+  }
+}
+
+void BridgedParamDecl_setSpecifier(BridgedParamDecl cDecl,
+                                   BridgedParamSpecifier cSpecifier) {
+  cDecl.unbridged()->setSpecifier(unbridge(cSpecifier));
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedSubscriptDecl
 //===----------------------------------------------------------------------===//

lib/AST/Bridging/DeclContextBridging.cpp

@@ -13,6 +13,7 @@
 #include "swift/AST/ASTBridging.h"
 
 #include "swift/AST/DeclContext.h"
+#include "swift/AST/Expr.h"
 
 using namespace swift;
 
@@ -29,3 +30,8 @@ BridgedDeclContext BridgedPatternBindingInitializer_asDeclContext(
     BridgedPatternBindingInitializer cInit) {
   return cInit.unbridged();
 }
+
+BridgedDeclContext
+BridgedClosureExpr_asDeclContext(BridgedClosureExpr cClosure) {
+  return cClosure.unbridged();
+}

lib/AST/Bridging/ExprBridging.cpp

@@ -123,23 +123,42 @@ BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext,
 
 BridgedClosureExpr BridgedClosureExpr_createParsed(
     BridgedASTContext cContext, BridgedDeclContext cDeclContext,
-    BridgedParameterList cParamList, BridgedBraceStmt body) {
-  DeclAttributes attributes;
-  SourceRange bracketRange;
-  SourceLoc asyncLoc;
-  SourceLoc throwsLoc;
-  SourceLoc arrowLoc;
-  SourceLoc inLoc;
-
+    BridgedDeclAttributes cAttributes, BridgedSourceRange cBracketRange,
+    BridgedNullableVarDecl cCapturedSelfDecl,
+    BridgedNullableParameterList cParameterList, BridgedSourceLoc cAsyncLoc,
+    BridgedSourceLoc cThrowsLoc, BridgedNullableTypeRepr cThrownType,
+    BridgedSourceLoc cArrowLoc, BridgedNullableTypeRepr cExplicitResultType,
+    BridgedSourceLoc cInLoc) {
   ASTContext &context = cContext.unbridged();
   DeclContext *declContext = cDeclContext.unbridged();
+  TypeExpr *throwsType = nullptr;
+  if (auto *tyR = cThrownType.unbridged())
+    throwsType = new (context) TypeExpr(tyR);
+  TypeExpr *explicitResultType = nullptr;
+  if (auto *tyR = cExplicitResultType.unbridged())
+    explicitResultType = new (context) TypeExpr(tyR);
+
+  return new (context)
+      ClosureExpr(cAttributes.unbridged(), cBracketRange.unbridged(),
+                  cCapturedSelfDecl.unbridged(), cParameterList.unbridged(),
+                  cAsyncLoc.unbridged(), cThrowsLoc.unbridged(), throwsType,
+                  cArrowLoc.unbridged(), cInLoc.unbridged(), explicitResultType,
+                  declContext);
+}
+
+void BridgedClosureExpr_setParameterList(BridgedClosureExpr cClosure,
+                                         BridgedParameterList cParams) {
+  cClosure.unbridged()->setParameterList(cParams.unbridged());
+}
+
+void BridgedClosureExpr_setHasAnonymousClosureVars(
+    BridgedClosureExpr cClosure) {
+  cClosure.unbridged()->setHasAnonymousClosureVars();
+}
 
-  auto *out = new (context) ClosureExpr(
-      attributes, bracketRange, nullptr, cParamList.unbridged(), asyncLoc,
-      throwsLoc,
-      /*FIXME:thrownType=*/nullptr, arrowLoc, inLoc, nullptr, declContext);
-  out->setBody(body.unbridged());
-  return out;
+void BridgedClosureExpr_setBody(BridgedClosureExpr cClosure,
+                                BridgedBraceStmt cBody) {
+  cClosure.unbridged()->setBody(cBody.unbridged());
 }
 
 BridgedCoerceExpr BridgedCoerceExpr_createParsed(BridgedASTContext cContext,

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -278,36 +278,131 @@ extension ASTGenVisitor {
     return createOperatorRefExpr(token: node.operator, kind: .binaryOperator)
   }
 
-  func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {
-    let params: BridgedParameterList
+  func generate(closureSignature node: ClosureSignatureSyntax) -> GeneratedClosureSignature {
+    var result = GeneratedClosureSignature()
+
+    // Attributes.
+    visitIfConfigElements(node.attributes, of: AttributeSyntax.self) { element in
+      switch element {
+      case .ifConfigDecl(let ifConfigDecl):
+        return .ifConfigDecl(ifConfigDecl)
+      case .attribute(let attribute):
+        return .underlying(attribute)
+      }
+    } body: { node in
+      if let attr = self.generateDeclAttribute(attribute: node) {
+        result.attributes.add(attr)
+      }
+    }
 
-    if let signature = node.signature {
-      // FIXME: Translate the signature, capture list, 'in' location, etc.
-      _ = signature
-      fatalError("unimplmented")
-    } else {
-      let lBraceLoc = self.generateSourceLoc(node.leftBrace)
-      params = BridgedParameterList.createParsed(
+    if let node = node.capture {
+      result.bracketRange = self.generateSourceRange(node)
+      let captures = node.items.lazy.map { node in
+        self.generate(closureCapture: node)
+      }
+      result.captureList = captures.bridgedArray(in: self)
+    }
+
+    switch node.parameterClause {
+    case .parameterClause(let node):
+      result.params = self.generate(closureParameterClause: node)
+    case .simpleInput(let node):
+      result.params = self.generate(closureShorthandParameterList: node)
+    case nil:
+      result.params = .createParsed(
         self.ctx,
-        leftParenLoc: lBraceLoc,
-        parameters: .init(),
-        rightParenLoc: lBraceLoc
+        leftParenLoc: nil,
+        parameters: BridgedArrayRef(),
+        rightParenLoc: nil
       )
     }
 
-    let body = BridgedBraceStmt.createParsed(
-      self.ctx,
-      lBraceLoc: self.generateSourceLoc(node.leftBrace),
-      elements: self.generate(codeBlockItemList: node.statements),
-      rBraceLoc: self.generateSourceLoc(node.rightBrace)
-    )
+    if let effects = node.effectSpecifiers {
+      result.asyncLoc = self.generateSourceLoc(effects.asyncSpecifier)
+      result.throwsLoc = self.generateSourceLoc(effects.throwsClause)
+      result.thrownType = effects.throwsClause?.type.map(generate(type:))
+    }
 
-    return .createParsed(
+    if let returnClause = node.returnClause {
+      result.arrowLoc = self.generateSourceLoc(returnClause.arrow)
+      result.explicitResultType = self.generate(type: returnClause.type)
+    }
+
+    result.inLoc = self.generateSourceLoc(node.inKeyword)
+
+    return result
+  }
+
+  func generate(closureCapture node: ClosureCaptureSyntax) {
+    fatalError("unimplemented")
+  }
+
+  struct GeneratedClosureSignature {
+    var attributes: BridgedDeclAttributes = BridgedDeclAttributes()
+    var bracketRange: BridgedSourceRange = BridgedSourceRange(start: nil, end: nil)
+    var captureList: BridgedArrayRef = BridgedArrayRef()
+    var capturedSelfDecl: BridgedVarDecl? = nil
+    var params: BridgedParameterList? = nil
+    var asyncLoc: BridgedSourceLoc = nil
+    var throwsLoc: BridgedSourceLoc = nil
+    var thrownType: BridgedTypeRepr? = nil
+    var arrowLoc: BridgedSourceLoc = nil
+    var explicitResultType: BridgedTypeRepr? = nil
+    var inLoc: BridgedSourceLoc = nil
+  }
+
+  func generate(closureExpr node: ClosureExprSyntax) -> BridgedClosureExpr {
+    let signature: GeneratedClosureSignature
+    if let node = node.signature {
+      signature = self.generate(closureSignature: node)
+    } else {
+      signature = GeneratedClosureSignature()
+    }
+
+    let expr = BridgedClosureExpr.createParsed(
       self.ctx,
       declContext: self.declContext,
-      parameterList: params,
-      body: body
+      attributes: signature.attributes,
+      bracketRange: signature.bracketRange,
+      capturedSelfDecl: BridgedNullableVarDecl(raw: signature.capturedSelfDecl?.raw),
+      parameterList: signature.params.asNullable,
+      asyncLoc: signature.asyncLoc,
+      throwsLoc: signature.throwsLoc,
+      thrownType: signature.thrownType.asNullable,
+      arrowLoc: signature.arrowLoc,
+      explicitResultType: signature.explicitResultType.asNullable,
+      inLoc: signature.inLoc
     )
+
+    let body = self.withDeclContext(expr.asDeclContext) {
+      BridgedBraceStmt.createParsed(
+        self.ctx,
+        lBraceLoc: self.generateSourceLoc(node.leftBrace),
+        elements: self.generate(codeBlockItemList: node.statements),
+        rBraceLoc: self.generateSourceLoc(node.rightBrace)
+      )
+    }
+
+    if signature.params == nil {
+      // TODO: Handle doller identifiers inside the closure.
+      let loc = self.generateSourceLoc(node.leftBrace)
+      let params = BridgedParameterList.createParsed(
+        self.ctx,
+        leftParenLoc: loc,
+        parameters: .init(),
+        rightParenLoc: loc
+      )
+      expr.setParameterList(params)
+      expr.setHasAnonymousClosureVars()
+    }
+
+    expr.setBody(body)
+
+    if signature.captureList.count > 0 {
+      // TODO: CaptureListExpr.
+    }
+
+    return expr
   }
 
   func generate(consumeExpr node: ConsumeExprSyntax) -> BridgedConsumeExpr {
@@ -502,6 +597,10 @@ extension ASTGenVisitor {
     if node.baseName.isEditorPlaceholder {
       return generateEditorPlaceholderExpr(token: node.baseName).asExpr
     }
+    if node.baseName.rawTokenKind == .dollarIdentifier {
+      // TODO: Handle dollar identifier in closure decl context.
+      // It's done in C++ Parser because it needs to handle inactive #if regions.
+    }
     let nameAndLoc = generateDeclNameRef(declReferenceExpr: node)
     return BridgedUnresolvedDeclRefExpr.createParsed(
       self.ctx,