[ASTGen] Start generating Patterns

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -177,6 +177,13 @@ namespace swift {
 #define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent)
 #include "swift/AST/TypeReprNodes.def"
 
+// Declare `.asPattern` on each BridgedXXXPattern type, which upcasts a wrapper
+// for a Pattern subclass to a BridgedPattern.
+#define PATTERN(Id, Parent)                                                    \
+  SWIFT_NAME("getter:Bridged" #Id "Pattern.asPattern(self:)")                  \
+  BridgedPattern Bridged##Id##Pattern_asPattern(Bridged##Id##Pattern pattern);
+#include "swift/AST/PatternNodes.def"
+
 //===----------------------------------------------------------------------===//
 // MARK: Diagnostic Engine
 //===----------------------------------------------------------------------===//
@@ -289,10 +296,10 @@ void BridgedDiagnostic_finish(BridgedDiagnostic cDiag);
 
 SWIFT_NAME(
     "BridgedPatternBindingDecl.createParsed(_:declContext:bindingKeywordLoc:"
-    "nameExpr:initializer:isStatic:isLet:)")
+    "pattern:initializer:isStatic:isLet:)")
 BridgedPatternBindingDecl BridgedPatternBindingDecl_createParsed(
     BridgedASTContext cContext, BridgedDeclContext cDeclContext,
-    BridgedSourceLoc cBindingKeywordLoc, BridgedExpr opaqueNameExpr,
+    BridgedSourceLoc cBindingKeywordLoc, BridgedPattern pattern,
     BridgedExpr opaqueInitExpr, bool isStatic, bool isLet);
 
 SWIFT_NAME("BridgedParamDecl.createParsed(_:declContext:specifierLoc:firstName:"
@@ -860,6 +867,16 @@ BridgedVarargTypeRepr_createParsed(BridgedASTContext cContext,
 SWIFT_NAME("BridgedTypeRepr.dump(self:)")
 void BridgedTypeRepr_dump(BridgedTypeRepr type);
 
+//===----------------------------------------------------------------------===//
+// MARK: Patterns
+//===----------------------------------------------------------------------===//
+
+SWIFT_NAME("BridgedNamedPattern.createParsed(_:declContext:name:loc:)")
+BridgedNamedPattern
+BridgedNamedPattern_createParsed(BridgedASTContext astContext,
+                                 BridgedDeclContext declContext,
+                                 BridgedIdentifier name, BridgedSourceLoc cLoc);
+
 //===----------------------------------------------------------------------===//
 // MARK: Misc
 //===----------------------------------------------------------------------===//

include/swift/AST/ASTBridgingWrappers.def

@@ -55,6 +55,11 @@
 #define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent)
 #include "swift/AST/TypeReprNodes.def"
 
+#ifndef PATTERN
+#define PATTERN(Id, Parent) AST_BRIDGING_WRAPPER_NONNULL(Id##Pattern)
+#endif
+#include "swift/AST/PatternNodes.def"
+
 // Some of the base classes need to be nullable to allow them to be used as
 // optional parameters.
 AST_BRIDGING_WRAPPER_NONNULL(Decl)

include/swift/AST/Decl.h

@@ -5838,13 +5838,6 @@ class VarDecl : public AbstractStorageDecl {
           SourceLoc nameLoc, Identifier name, DeclContext *dc,
           StorageIsMutable_t supportsMutation);
 
-protected:
-  // Only \c ParamDecl::setSpecifier is allowed to flip this - and it's also
-  // on the way out of that business.
-  void setIntroducer(Introducer value) {
-    Bits.VarDecl.Introducer = uint8_t(value);
-  }
-
 public:
   VarDecl(bool isStatic, Introducer introducer,
           SourceLoc nameLoc, Identifier name, DeclContext *dc)
@@ -6064,6 +6057,12 @@ class VarDecl : public AbstractStorageDecl {
   /// upon any kind of access?
   bool isOrdinaryStoredProperty() const;
 
+  /// Set the introducer kind.
+  /// Note: do not call this after type checking begun.
+  void setIntroducer(Introducer value) {
+    Bits.VarDecl.Introducer = uint8_t(value);
+  }
+
   Introducer getIntroducer() const {
     return Introducer(Bits.VarDecl.Introducer);
   }

lib/AST/ASTBridging.cpp

@@ -117,6 +117,14 @@ bool BridgedASTContext_langOptsHasFeature(BridgedASTContext cContext,
 #define ABSTRACT_TYPEREPR(Id, Parent) TYPEREPR(Id, Parent)
 #include "swift/AST/TypeReprNodes.def"
 
+// Define `.asPattern` on each BridgedXXXPattern type.
+#define PATTERN(Id, Parent)                                                    \
+  BridgedPattern Bridged##Id##Pattern_asPattern(                               \
+      Bridged##Id##Pattern pattern) {                                          \
+    return static_cast<Pattern *>(pattern.unbridged());                        \
+  }
+#include "swift/AST/PatternNodes.def"
+
 //===----------------------------------------------------------------------===//
 // MARK: Diagnostics
 //===----------------------------------------------------------------------===//
@@ -274,18 +282,25 @@ void BridgedDiagnostic_finish(BridgedDiagnostic cDiag) {
 
 BridgedPatternBindingDecl BridgedPatternBindingDecl_createParsed(
     BridgedASTContext cContext, BridgedDeclContext cDeclContext,
-    BridgedSourceLoc cBindingKeywordLoc, BridgedExpr nameExpr,
+    BridgedSourceLoc cBindingKeywordLoc, BridgedPattern cPattern,
     BridgedExpr initExpr, bool isStatic, bool isLet) {
   ASTContext &context = cContext.unbridged();
   DeclContext *declContext = cDeclContext.unbridged();
 
-  auto *name = cast<UnresolvedDeclRefExpr>(nameExpr.unbridged());
-  auto *varDecl = new (context) VarDecl(
-      isStatic, isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var,
-      name->getLoc(), name->getName().getBaseIdentifier(), declContext);
-  auto *pattern = new (context) NamedPattern(varDecl);
+  Pattern *pattern = cPattern.unbridged();
+
+  VarDecl::Introducer introducer =
+      isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var;
+
+  // Configure all vars.
+  pattern->forEachVariable([&](VarDecl *VD) {
+    VD->setStatic(isStatic);
+    VD->setIntroducer(introducer);
+  });
+
   return PatternBindingDecl::create(context,
-                                    /*StaticLoc=*/SourceLoc(), // FIXME
+                                    /*StaticLoc=*/SourceLoc(),
+                                    // FIXME: 'class' spelling kind.
                                     isStatic ? StaticSpellingKind::KeywordStatic
                                              : StaticSpellingKind::None,
                                     cBindingKeywordLoc.unbridged(), pattern,
@@ -1255,6 +1270,26 @@ BridgedExistentialTypeRepr_createParsed(BridgedASTContext cContext,
       ExistentialTypeRepr(cAnyLoc.unbridged(), baseTy.unbridged());
 }
 
+//===----------------------------------------------------------------------===//
+// MARK: Patterns
+//===----------------------------------------------------------------------===//
+
+BridgedNamedPattern
+BridgedNamedPattern_createParsed(BridgedASTContext cContext,
+                                 BridgedDeclContext cDeclContext,
+                                 BridgedIdentifier name, BridgedSourceLoc loc) {
+  auto &context = cContext.unbridged();
+  auto *dc = cDeclContext.unbridged();
+
+  // Note 'isStatic' and the introducer value are temporary.
+  // The outer context should set the correct values.
+  auto *varDecl = new (context) VarDecl(
+      /*isStatic=*/false, VarDecl::Introducer::Let, loc.unbridged(),
+      name.unbridged(), dc);
+  auto *pattern = new (context) NamedPattern(varDecl);
+  return pattern;
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: Misc
 //===----------------------------------------------------------------------===//

lib/ASTGen/Sources/ASTGen/ASTGen.swift

@@ -14,7 +14,7 @@ import ASTBridging
 import BasicBridging
 import ParseBridging
 // Needed to use BumpPtrAllocator
-@_spi(BumpPtrAllocator) @_spi(ExperimentalLanguageFeatures) import SwiftSyntax
+@_spi(BumpPtrAllocator) import SwiftSyntax
 
 import struct SwiftDiagnostics.Diagnostic
 

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -305,7 +305,7 @@ extension ASTGenVisitor {
       self.ctx,
       declContext: self.declContext,
       bindingKeywordLoc: node.bindingSpecifier.bridgedSourceLoc(in: self),
-      nameExpr: pattern.castToExpr,
+      pattern: pattern,
       initializer: initializer,
       isStatic: isStatic,
       isLet: isLet

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -255,12 +255,6 @@ extension ASTGenVisitor {
     return .createParsed(self.ctx, base: name, loc: nameLoc)
   }
 
-  public func generate(_ node: IdentifierPatternSyntax) -> BridgedUnresolvedDeclRefExpr {
-    let (name, nameLoc) = node.identifier.bridgedIdentifierAndSourceLoc(in: self)
-
-    return .createParsed(self.ctx, base: name, loc: nameLoc)
-  }
-
   public func generate(_ node: MemberAccessExprSyntax) -> BridgedUnresolvedDotExpr {
     let loc = node.bridgedSourceLoc(in: self)
     let base = generate(expr: node.base!)

lib/ASTGen/Sources/ASTGen/Patterns.swift

@@ -1,29 +1,49 @@
+//===--- Patterns.swift ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
 
 import ASTBridging
 import BasicBridging
 import SwiftDiagnostics
 @_spi(ExperimentalLanguageFeatures) import SwiftSyntax
 
 extension ASTGenVisitor {
-  func generate(pattern node: PatternSyntax) -> ASTNode {
+  func generate(pattern node: PatternSyntax) -> BridgedPattern {
     switch node.as(PatternSyntaxEnum.self) {
-    case .expressionPattern(_):
+    case .expressionPattern:
       break
     case .identifierPattern(let node):
-      // FIXME: Generate proper pattern instead of temporary Expr.
-      return .expr(self.generate(node).asExpr)
-    case .isTypePattern(_):
+      return self.generate(identifierPattern: node).asPattern
+    case .isTypePattern:
       break
-    case .missingPattern(_):
+    case .missingPattern:
       break
-    case .tuplePattern(_):
+    case .tuplePattern:
       break
-    case .valueBindingPattern(_):
+    case .valueBindingPattern:
       break
-    case .wildcardPattern(_):
+    case .wildcardPattern:
       break
     }
-    fatalError("unimplmented")
+
+    preconditionFailure("unimplemented")
+  }
+
+  func generate(identifierPattern node: IdentifierPatternSyntax) -> BridgedNamedPattern {
+    let (name, nameLoc) = node.identifier.bridgedIdentifierAndSourceLoc(in: self)
+    return .createParsed(
+      ctx, declContext: declContext,
+      name: name,
+      loc: nameLoc
+    )
   }
 }