[ASTGen] Generate CaptureListExpr

rintaro · rintaro · commit 0ced6e06b435 · 2025-02-16T05:22:46.000-08:00
Move the capture list entry construction logic to
CaptureListEntry::createParsed() so that ASTGen can use it.
diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h
@@ -37,6 +37,7 @@ class AvailabilityDomain;
 class Argument;
 class ASTContext;
 struct ASTNode;
+struct CaptureListEntry;
 class DeclAttributes;
 class DeclBaseName;
 class DeclNameLoc;
@@ -55,6 +56,7 @@ enum class PlatformKind : uint8_t;
 class ProtocolConformanceRef;
 class RegexLiteralPatternFeature;
 class RegexLiteralPatternFeatureKind;
+enum class ReferenceOwnership : uint8_t;
 class Type;
 class CanType;
 class TypeBase;
@@ -114,6 +116,10 @@ inline const void *_Nullable BridgedIdentifier_raw(BridgedIdentifier ident) {
   return ident.Raw;
 }
 
+SWIFT_NAME("getter:BridgedIdentifier.str(self:)")
+BRIDGED_INLINE BridgedStringRef
+BridgedIdentifier_getStr(BridgedIdentifier ident);
+
 SWIFT_NAME("getter:BridgedIdentifier.isOperator(self:)")
 BRIDGED_INLINE bool BridgedIdentifier_isOperator(const BridgedIdentifier);
 
@@ -1104,11 +1110,14 @@ BridgedRawDocCommentAttr_createParsed(BridgedASTContext cContext,
                                       BridgedCharSourceRange cRange);
 
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedReferenceOwnership {
+  BridgedReferenceOwnershipStrong,
   BridgedReferenceOwnershipWeak,
   BridgedReferenceOwnershipUnowned,
   BridgedReferenceOwnershipUnmanaged,
 };
 
+swift::ReferenceOwnership unbridged(BridgedReferenceOwnership kind);
+
 SWIFT_NAME("BridgedReferenceOwnershipAttr.createParsed(_:atLoc:range:kind:)")
 BridgedReferenceOwnershipAttr BridgedReferenceOwnershipAttr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
@@ -1625,6 +1634,33 @@ BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext,
                                              BridgedExpr fn,
                                              BridgedArgumentList args);
 
+class BridgedCaptureListEntry {
+  swift::PatternBindingDecl *_Nonnull PBD;
+
+public:
+  BRIDGED_INLINE BridgedCaptureListEntry(swift::CaptureListEntry CLE);
+
+  BRIDGED_INLINE swift::CaptureListEntry unbridged() const;
+};
+
+SWIFT_NAME("BridgedCaptureListEntry.createParsed(_:declContext:ownership:"
+           "ownershipRange:name:nameLoc:equalLoc:initializer:)")
+BridgedCaptureListEntry BridegedCaptureListEntry_createParsed(
+    BridgedASTContext cContext, BridgedDeclContext cDeclContext,
+    BridgedReferenceOwnership cOwnershipKind,
+    BridgedSourceRange cOwnershipRange, BridgedIdentifier cName,
+    BridgedSourceLoc cNameLoc, BridgedSourceLoc cEqualLoc,
+    BridgedExpr cInitializer);
+
+SWIFT_NAME("getter:BridgedCaptureListEntry.varDecl(self:)")
+BRIDGED_INLINE BridgedVarDecl
+BridegedCaptureListEntry_getVar(BridgedCaptureListEntry entry);
+
+SWIFT_NAME("BridgedCaptureListExpr.createParsed(_:captureList:closure:)")
+BridgedCaptureListExpr BridgedCaptureListExpr_createParsed(BridgedASTContext cContext,
+                                                           BridgedArrayRef cCaptureList,
+                                                           BridgedClosureExpr cClosure);
+
 SWIFT_NAME("BridgedClosureExpr.createParsed(_:declContext:attributes:"
            "bracketRange:capturedSelfDecl:parameterList:asyncLoc:throwsLoc:"
            "thrownType:arrowLoc:explicitResultType:inLoc:)")
diff --git a/include/swift/AST/ASTBridgingImpl.h b/include/swift/AST/ASTBridgingImpl.h
@@ -40,7 +40,10 @@ swift::Identifier BridgedIdentifier::unbridged() const {
   return swift::Identifier::getFromOpaquePointer(Raw);
 }
 
-SWIFT_NAME("getter:BridgedIdentifier.isOperator(self:)")
+BridgedStringRef BridgedIdentifier_getStr(const BridgedIdentifier ident) {
+  return ident.unbridged().str();
+}
+
 bool BridgedIdentifier_isOperator(const BridgedIdentifier ident) {
   return ident.unbridged().isOperator();
 }
@@ -629,6 +632,20 @@ swift::StmtConditionElement BridgedStmtConditionElement::unbridged() const {
   return swift::StmtConditionElement::fromOpaqueValue(Raw);
 }
 
+//===----------------------------------------------------------------------===//
+// MARK: BridgedCaptureListEntry
+//===----------------------------------------------------------------------===//
+
+BridgedCaptureListEntry::BridgedCaptureListEntry(swift::CaptureListEntry CLE)
+    : PBD(CLE.PBD) {}
+
+swift::CaptureListEntry BridgedCaptureListEntry::unbridged() const {
+  return swift::CaptureListEntry(PBD);
+}
+
+BridgedVarDecl BridegedCaptureListEntry_getVar(BridgedCaptureListEntry entry) {
+  return entry.unbridged().getVar();
+}
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -4562,6 +4562,11 @@ struct CaptureListEntry {
 
   explicit CaptureListEntry(PatternBindingDecl *PBD);
 
+  static CaptureListEntry
+  createParsed(ASTContext &Ctx, ReferenceOwnership ownershipKind,
+               SourceRange ownershipRange, Identifier name, SourceLoc nameLoc,
+               SourceLoc equalLoc, Expr *initializer, DeclContext *DC);
+
   VarDecl *getVar() const;
   bool isSimpleSelfCapture(bool excludeWeakCaptures = true) const;
 };
diff --git a/include/swift/Basic/BasicBridging.h b/include/swift/Basic/BasicBridging.h
@@ -251,6 +251,10 @@ BRIDGED_INLINE SwiftInt BridgedStringRef_count(BridgedStringRef str);
 SWIFT_NAME("getter:BridgedStringRef.isEmpty(self:)")
 BRIDGED_INLINE bool BridgedStringRef_empty(BridgedStringRef str);
 
+SWIFT_NAME("BridgedStringRef.equals(self:_:)")
+BRIDGED_INLINE bool BridgedStringRef_equals(BridgedStringRef lhs,
+                                            BridgedStringRef rhs);
+
 class BridgedOwnedString {
   char *_Nonnull Data;
   size_t Length;
diff --git a/include/swift/Basic/BasicBridgingImpl.h b/include/swift/Basic/BasicBridgingImpl.h
@@ -70,6 +70,10 @@ bool BridgedStringRef_empty(BridgedStringRef str) {
   return str.unbridged().empty();
 }
 
+bool BridgedStringRef_equals(BridgedStringRef lhs, BridgedStringRef rhs) {
+  return lhs.unbridged() == rhs.unbridged();
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedOwnedString
 //===----------------------------------------------------------------------===//
diff --git a/lib/AST/Bridging/DeclAttributeBridging.cpp b/lib/AST/Bridging/DeclAttributeBridging.cpp
@@ -559,8 +559,10 @@ BridgedRawDocCommentAttr_createParsed(BridgedASTContext cContext,
   return new (cContext.unbridged()) RawDocCommentAttr(cRange.unbridged());
 }
 
-static ReferenceOwnership unbridged(BridgedReferenceOwnership kind) {
+ReferenceOwnership unbridged(BridgedReferenceOwnership kind) {
   switch (kind) {
+  case BridgedReferenceOwnershipStrong:
+    return ReferenceOwnership::Strong;
   case BridgedReferenceOwnershipWeak:
     return ReferenceOwnership::Weak;
   case BridgedReferenceOwnershipUnowned:
diff --git a/lib/AST/Bridging/ExprBridging.cpp b/lib/AST/Bridging/ExprBridging.cpp
@@ -121,6 +121,31 @@ BridgedCallExpr BridgedCallExpr_createParsed(BridgedASTContext cContext,
                           /*implicit*/ false);
 }
 
+BridgedCaptureListEntry BridegedCaptureListEntry_createParsed(
+    BridgedASTContext cContext, BridgedDeclContext cDeclContext,
+    BridgedReferenceOwnership cOwnershipKind,
+    BridgedSourceRange cOwnershipRange, BridgedIdentifier cName,
+    BridgedSourceLoc cNameLoc, BridgedSourceLoc cEqualLoc,
+    BridgedExpr cInitializer) {
+  return CaptureListEntry::createParsed(
+      cContext.unbridged(), unbridged(cOwnershipKind),
+      cOwnershipRange.unbridged(), cName.unbridged(), cNameLoc.unbridged(),
+      cEqualLoc.unbridged(), cInitializer.unbridged(),
+      cDeclContext.unbridged());
+}
+
+BridgedCaptureListExpr
+BridgedCaptureListExpr_createParsed(BridgedASTContext cContext,
+                                    BridgedArrayRef cCaptureList,
+                                    BridgedClosureExpr cClosure) {
+  SmallVector<CaptureListEntry, 4> captureList;
+  for (auto e : cCaptureList.unbridged<BridgedCaptureListEntry>())
+    captureList.push_back(e.unbridged());
+
+  return CaptureListExpr::create(cContext.unbridged(), captureList,
+                                 cClosure.unbridged());
+}
+
 BridgedClosureExpr BridgedClosureExpr_createParsed(
     BridgedASTContext cContext, BridgedDeclContext cDeclContext,
     BridgedDeclAttributes cAttributes, BridgedSourceRange cBracketRange,
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1360,6 +1360,34 @@ CaptureListEntry::CaptureListEntry(PatternBindingDecl *PBD) : PBD(PBD) {
          "Capture lists only support single-var patterns");
 }
 
+CaptureListEntry CaptureListEntry::createParsed(
+    ASTContext &Ctx, ReferenceOwnership ownershipKind,
+    SourceRange ownershipRange, Identifier name, SourceLoc nameLoc,
+    SourceLoc equalLoc, Expr *initializer, DeclContext *DC) {
+
+  auto introducer =
+      (ownershipKind != ReferenceOwnership::Weak ? VarDecl::Introducer::Let
+                                                 : VarDecl::Introducer::Var);
+  auto *VD =
+      new (Ctx) VarDecl(/*isStatic==*/false, introducer, nameLoc, name, DC);
+
+  if (ownershipKind != ReferenceOwnership::Strong)
+    VD->getAttrs().add(
+        new (Ctx) ReferenceOwnershipAttr(ownershipRange, ownershipKind));
+
+  auto *pattern = NamedPattern::createImplicit(Ctx, VD);
+
+  auto *PBD = PatternBindingDecl::create(Ctx, /*StaticLoc=*/SourceLoc(),
+                                         StaticSpellingKind::None, nameLoc,
+                                         pattern, equalLoc, initializer, DC);
+  CaptureListEntry CLE(PBD);
+
+  if (CLE.isSimpleSelfCapture())
+    VD->setIsSelfParamCapture();
+
+  return CLE;
+}
+
 VarDecl *CaptureListEntry::getVar() const {
   return PBD->getSingleVar();
 }
diff --git a/lib/ASTGen/Sources/ASTGen/Bridge.swift b/lib/ASTGen/Sources/ASTGen/Bridge.swift
@@ -38,6 +38,7 @@ extension BridgedNullableParameterList: /*@retroactive*/ swiftASTGen.BridgedNull
 extension BridgedNullablePatternBindingInitializer: /*@retroactive*/ swiftASTGen.BridgedNullable {}
 extension BridgedNullableCustomAttributeInitializer: /*@retroactive*/ swiftASTGen.BridgedNullable {}
 extension BridgedNullableArgumentList: /*@retroactive*/ swiftASTGen.BridgedNullable {}
+extension BridgedNullableVarDecl: /*@retroactive*/ swiftASTGen.BridgedNullable {}
 
 extension BridgedIdentifier: /*@retroactive*/ Swift.Equatable {
   public static func == (lhs: Self, rhs: Self) -> Bool {
@@ -92,6 +93,9 @@ extension BridgedCustomAttributeInitializer: BridgedHasNullable {
 extension BridgedArgumentList: BridgedHasNullable {
   typealias Nullable = BridgedNullableArgumentList
 }
+extension BridgedVarDecl: BridgedHasNullable {
+  typealias Nullable = BridgedNullableVarDecl
+}
 
 public extension BridgedSourceLoc {
   /// Form a source location at the given absolute position in `buffer`.
@@ -162,6 +166,12 @@ extension BridgedStringRef: /*@retroactive*/ Swift.ExpressibleByStringLiteral {
   }
 }
 
+extension BridgedStringRef: /*@retroactive*/ Swift.Equatable {
+  public static func ==(lhs: BridgedStringRef, rhs: BridgedStringRef) -> Bool {
+    lhs.equals(rhs)
+  }
+}
+
 extension VersionTuple {
   var bridged: BridgedVersionTuple {
     switch self.components.count {
diff --git a/lib/ASTGen/Sources/ASTGen/Exprs.swift b/lib/ASTGen/Sources/ASTGen/Exprs.swift
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
diff --git a/test/ASTGen/exprs.swift b/test/ASTGen/exprs.swift
