diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h
index 2e58d06514aec..3ad8397ec81c8 100644
--- a/include/swift/AST/ASTBridging.h
+++ b/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
 //===----------------------------------------------------------------------===//
diff --git a/include/swift/AST/ASTBridgingWrappers.def b/include/swift/AST/ASTBridgingWrappers.def
index 5bbb7b2d3e901..bc109824ee4e6 100644
--- a/include/swift/AST/ASTBridgingWrappers.def
+++ b/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)
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
index fce002173c8a6..f7ced430d5755 100644
--- a/include/swift/AST/Decl.h
+++ b/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);
   }
diff --git a/lib/AST/ASTBridging.cpp b/lib/AST/ASTBridging.cpp
index 83b88a9c6a6e8..2338573fd885e 100644
--- a/lib/AST/ASTBridging.cpp
+++ b/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
 //===----------------------------------------------------------------------===//
diff --git a/lib/ASTGen/CMakeLists.txt b/lib/ASTGen/CMakeLists.txt
index d7505123010d6..cc0ec257acd7a 100644
--- a/lib/ASTGen/CMakeLists.txt
+++ b/lib/ASTGen/CMakeLists.txt
@@ -17,6 +17,7 @@ add_pure_swift_host_library(swiftASTGen STATIC
   Sources/ASTGen/Literals.swift
   Sources/ASTGen/Macros.swift
   Sources/ASTGen/ParameterClause.swift
+  Sources/ASTGen/Patterns.swift
   Sources/ASTGen/PluginHost.swift
   Sources/ASTGen/SourceFile.swift
   Sources/ASTGen/SourceManager.swift
diff --git a/lib/ASTGen/Sources/ASTGen/ASTGen.swift b/lib/ASTGen/Sources/ASTGen/ASTGen.swift
index 2a4dbd3a4fcdf..a4f07e32e9e69 100644
--- a/lib/ASTGen/Sources/ASTGen/ASTGen.swift
+++ b/lib/ASTGen/Sources/ASTGen/ASTGen.swift
@@ -132,7 +132,7 @@ struct ASTGenVisitor {
 
     for element in node.statements {
       let loc = element.bridgedSourceLoc(in: self)
-      let swiftASTNodes = generate(element)
+      let swiftASTNodes = generate(codeBlockItem: element)
       switch swiftASTNodes {
       case .decl(let d):
         out.append(d.raw)
@@ -188,179 +188,67 @@ extension ASTGenVisitor {
 }
 
 extension ASTGenVisitor {
-  func generate(_ node: DeclSyntax) -> BridgedDecl {
-    return generate(Syntax(node)).castToDecl
-  }
-
-  func generate(_ node: ExprSyntax) -> BridgedExpr {
-    if !isExprMigrated(node) {
-      return generateWithLegacy(node)
+  /// Generate AST from a Syntax node. The node must be a decl, stmt, expr, or
+  /// type.
+  func generate(_ node: Syntax) -> ASTNode {
+    if let decl = node.as(DeclSyntax.self) {
+      return .decl(self.generate(decl: decl))
     }
-    return generate(Syntax(node)).castToExpr
-  }
-
-  func generate(_ node: PatternSyntax) -> ASTNode {
-    return generate(Syntax(node))
-  }
-
-  func generate(_ node: StmtSyntax) -> BridgedStmt {
-    return generate(Syntax(node)).castToStmt
-  }
-
-  func generate(_ node: TypeSyntax) -> BridgedTypeRepr {
-    if !isTypeMigrated(node) {
-      return generateWithLegacy(node)
+    if let stmt = node.as(StmtSyntax.self) {
+      return .stmt(self.generate(stmt: stmt))
+    }
+    if let expr = node.as(ExprSyntax.self) {
+      return .expr(self.generate(expr: expr))
+    }
+    if let type = node.as(TypeSyntax.self) {
+      return .type(self.generate(type: type))
     }
-    return generate(Syntax(node)).castToType
-  }
-
-  func generate(_ node: some SyntaxChildChoices) -> ASTNode {
-    return self.generate(Syntax(node))
-  }
 
-  func generate(_ node: Syntax) -> ASTNode {
-    switch node.as(SyntaxEnum.self) {
-    case .actorDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .arrayElement(let node):
-      return .expr(generate(node))
-    case .arrayExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .arrayType(let node):
-      return .type(generate(node))
-    case .associatedTypeDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .attributedType(let node):
-      return .type(generate(node))
-    case .booleanLiteralExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .classDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .closureExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .codeBlock(let node):
-      return .stmt(generate(node).asStmt)
-    case .codeBlockItem(let node):
-      return generate(node)
-    case .compositionType(let node):
-      return .type(generate(node))
-    case .conditionElement(let node):
-      return generate(node)
-    case .declReferenceExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .deinitializerDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .dictionaryType(let node):
-      return .type(generate(node))
-    case .enumCaseDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .enumDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .expressionStmt(let node):
-      return .stmt(generate(node))
-    case .extensionDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .functionCallExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .functionDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .functionType(let node):
-      return .type(generate(node))
-    case .identifierPattern(let node):
-      return .expr(generate(node).asExpr)
-    case .identifierType(let node):
-      return .type(generate(node))
-    case .ifExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .implicitlyUnwrappedOptionalType(let node):
-      return .type(generate(node))
-    case .importDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .initializerClause(let node):
-      return .expr(generate(node))
-    case .initializerDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .integerLiteralExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .memberAccessExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .memberBlockItem(let node):
-      return .decl(generate(node))
-    case .memberType(let node):
-      return .type(generate(node))
-    case .metatypeType(let node):
-      return .type(generate(node))
-    case .namedOpaqueReturnType(let node):
-      return .type(generate(node))
-    case .nilLiteralExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .operatorDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .optionalType(let node):
-      return .type(generate(node))
-    case .packExpansionType(let node):
-      return .type(generate(node))
-    case .precedenceGroupDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .protocolDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .returnStmt(let node):
-      return .stmt(generate(node).asStmt)
-    case .someOrAnyType(let node):
-      return .type(generate(node))
-    case .stringLiteralExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .structDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .tupleExpr(let node):
-      return .expr(generate(node).asExpr)
-    case .tupleType(let node):
-      return .type(generate(node))
-    case .typeAliasDecl(let node):
-      return .decl(generate(node).asDecl)
-    case .variableDecl(let node):
-      return .decl(generate(node).asDecl)
-
-    // Un-migrated nodes.
-    case _ where node.is(ExprSyntax.self):
-      return .expr(self.generateWithLegacy(node.cast(ExprSyntax.self)))
-    case _ where node.is(StmtSyntax.self):
-      return .stmt(self.generateWithLegacy(node.cast(StmtSyntax.self)))
-    case _ where node.is(DeclSyntax.self):
-      return .decl(self.generateWithLegacy(node.cast(DeclSyntax.self)))
+    // --- Special cases where `node` doesn't belong to one of the base kinds.
 
-    default:
-      fatalError("case does not correspond to an ASTNode")
+    // CodeBlockSyntax -> BraceStmt.
+    if let node = node.as(CodeBlockSyntax.self) {
+      return .stmt(self.generate(codeBlock: node).asStmt)
+    }
+    // CodeBlockItemSyntax -> ASTNode.
+    if let node = node.as(CodeBlockItemSyntax.self) {
+      return self.generate(codeBlockItem: node)
     }
+
+    fatalError("node does not correspond to an ASTNode \(node.kind)")
   }
 }
 
 // Misc visits.
 // TODO: Some of these are called within a single file/method; we may want to move them to the respective files.
 extension ASTGenVisitor {
+  func generate(_ node: some SyntaxChildChoices) -> ASTNode {
+    return self.generate(Syntax(node))
+  }
+
   public func generate(_ node: MemberBlockItemSyntax) -> BridgedDecl {
-    generate(node.decl)
+    generate(decl: node.decl)
   }
 
   public func generate(_ node: InitializerClauseSyntax) -> BridgedExpr {
-    generate(node.value)
+    generate(expr: node.value)
   }
 
   public func generate(_ node: ConditionElementSyntax) -> ASTNode {
     generate(node.condition)
   }
 
-  public func generate(_ node: CodeBlockItemSyntax) -> ASTNode {
+  public func generate(codeBlockItem node: CodeBlockItemSyntax) -> ASTNode {
     generate(node.item)
   }
 
   public func generate(_ node: ArrayElementSyntax) -> BridgedExpr {
-    generate(node.expression)
+    generate(expr: node.expression)
   }
 
   @inline(__always)
   func generate(_ node: CodeBlockItemListSyntax) -> BridgedArrayRef {
-    node.lazy.map { self.generate($0).bridged }.bridgedArray(in: self)
+    node.lazy.map { self.generate(codeBlockItem: $0).bridged }.bridgedArray(in: self)
   }
 }
 
@@ -373,7 +261,7 @@ extension ASTGenVisitor {
       return nil
     }
 
-    return self.generate(node)
+    return self.generate(type: node)
   }
 
   @inline(__always)
@@ -382,7 +270,7 @@ extension ASTGenVisitor {
       return nil
     }
 
-    return self.generate(node)
+    return self.generate(expr: node)
   }
 
   @inline(__always)
diff --git a/lib/ASTGen/Sources/ASTGen/Decls.swift b/lib/ASTGen/Sources/ASTGen/Decls.swift
index 6bd3530f92f88..a60ffeefe365e 100644
--- a/lib/ASTGen/Sources/ASTGen/Decls.swift
+++ b/lib/ASTGen/Sources/ASTGen/Decls.swift
@@ -18,6 +18,60 @@ import SwiftDiagnostics
 // MARK: - TypeDecl
 
 extension ASTGenVisitor {
+  func generate(decl node: DeclSyntax) -> BridgedDecl {
+    switch node.as(DeclSyntaxEnum.self) {
+    case .accessorDecl:
+      break
+    case .actorDecl(let node):
+      return self.generate(node).asDecl
+    case .associatedTypeDecl(let node):
+      return self.generate(node).asDecl
+    case .classDecl(let node):
+      return self.generate(node).asDecl
+    case .deinitializerDecl(let node):
+      return self.generate(node).asDecl
+    case .editorPlaceholderDecl:
+      break
+    case .enumCaseDecl(let node):
+      return self.generate(node).asDecl
+    case .enumDecl(let node):
+      return self.generate(node).asDecl
+    case .extensionDecl(let node):
+      return self.generate(node).asDecl
+    case .functionDecl(let node):
+      return self.generate(node).asDecl
+    case .ifConfigDecl:
+      break
+    case .importDecl(let node):
+      return self.generate(node).asDecl
+    case .initializerDecl(let node):
+      return self.generate(node).asDecl
+    case .macroDecl:
+      break
+    case .macroExpansionDecl:
+      break
+    case .missingDecl:
+      break
+    case .operatorDecl(let node):
+      return self.generate(node).asDecl
+    case .poundSourceLocation:
+      break
+    case .precedenceGroupDecl(let node):
+      return self.generate(node).asDecl
+    case .protocolDecl(let node):
+      return self.generate(node).asDecl
+    case .structDecl(let node):
+      return self.generate(node).asDecl
+    case .subscriptDecl:
+      break
+    case .typeAliasDecl(let node):
+      return self.generate(node).asDecl
+    case .variableDecl(let node):
+      return self.generate(node).asDecl
+    }
+    return self.generateWithLegacy(node)
+  }
+
   public func generate(_ node: TypeAliasDeclSyntax) -> BridgedTypeAliasDecl {
     let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
 
@@ -29,7 +83,7 @@ extension ASTGenVisitor {
       nameLoc: nameLoc,
       genericParamList: self.generate(node.genericParameterClause).asNullable,
       equalLoc: node.initializer.equal.bridgedSourceLoc(in: self),
-      underlyingType: self.generate(node.initializer.value),
+      underlyingType: self.generate(type: node.initializer.value),
       genericWhereClause: self.generate(node.genericWhereClause).asNullable
     )
   }
@@ -193,7 +247,7 @@ extension ASTGenVisitor {
       self.ctx,
       declContext: self.declContext,
       extensionKeywordLoc: node.extensionKeyword.bridgedSourceLoc(in: self),
-      extendedType: self.generate(node.extendedType),
+      extendedType: self.generate(type: node.extendedType),
       inheritedTypes: self.generate(node.inheritanceClause?.inheritedTypes),
       genericWhereClause: self.generate(node.genericWhereClause).asNullable,
       braceRange: BridgedSourceRange(
@@ -241,7 +295,7 @@ extension ASTGenVisitor {
 
 extension ASTGenVisitor {
   public func generate(_ node: VariableDeclSyntax) -> BridgedPatternBindingDecl {
-    let pattern = generate(node.bindings.first!.pattern)
+    let pattern = generate(pattern: node.bindings.first!.pattern)
     let initializer = generate(node.bindings.first!.initializer!)
 
     let isStatic = false  // TODO: compute this
@@ -251,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
@@ -286,7 +340,7 @@ extension ASTGenVisitor {
 
     if let body = node.body {
       self.withDeclContext(decl.asDeclContext) {
-        decl.setParsedBody(self.generate(body))
+        decl.setParsedBody(self.generate(codeBlock: body))
       }
     }
 
@@ -310,7 +364,7 @@ extension ASTGenVisitor {
 
     if let body = node.body {
       self.withDeclContext(decl.asDeclContext) {
-        decl.setParsedBody(self.generate(body))
+        decl.setParsedBody(self.generate(codeBlock: body))
       }
     }
 
@@ -326,7 +380,7 @@ extension ASTGenVisitor {
 
     if let body = node.body {
       self.withDeclContext(decl.asDeclContext) {
-        decl.setParsedBody(self.generate(body))
+        decl.setParsedBody(self.generate(codeBlock: body))
       }
     }
 
@@ -539,7 +593,7 @@ extension ASTGenVisitor {
 
   @inline(__always)
   func generate(_ node: InheritedTypeListSyntax) -> BridgedArrayRef {
-    node.lazy.map { self.generate($0.type) }.bridgedArray(in: self)
+    node.lazy.map { self.generate(type: $0.type) }.bridgedArray(in: self)
   }
 
   @inline(__always)
diff --git a/lib/ASTGen/Sources/ASTGen/Exprs.swift b/lib/ASTGen/Sources/ASTGen/Exprs.swift
index 4c3f064a0132f..b2f0854dd8111 100644
--- a/lib/ASTGen/Sources/ASTGen/Exprs.swift
+++ b/lib/ASTGen/Sources/ASTGen/Exprs.swift
@@ -83,6 +83,121 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
 }
 
 extension ASTGenVisitor {
+  func generate(expr node: ExprSyntax) -> BridgedExpr {
+    guard isExprMigrated(node) else {
+      return generateWithLegacy(node)
+    }
+    switch node.as(ExprSyntaxEnum.self) {
+    case .arrayExpr(let node):
+      return self.generate(node).asExpr
+    case .arrowExpr:
+      break
+    case .asExpr:
+      break
+    case .assignmentExpr:
+      break
+    case .awaitExpr:
+      break
+    case .binaryOperatorExpr:
+      break
+    case .booleanLiteralExpr(let node):
+      return self.generate(node).asExpr
+    case .borrowExpr:
+      break
+    case .canImportExpr:
+      break
+    case .canImportVersionInfo:
+      break
+    case .closureExpr(let node):
+      return self.generate(node).asExpr
+    case .consumeExpr:
+      break
+    case .copyExpr:
+      break
+    case .declReferenceExpr(let node):
+      return self.generate(node).asExpr
+    case .dictionaryExpr:
+      break
+    case .discardAssignmentExpr:
+      break
+    case .doExpr:
+      break
+    case .editorPlaceholderExpr:
+      break
+    case .floatLiteralExpr:
+      break
+    case .forceUnwrapExpr:
+      break
+    case .functionCallExpr(let node):
+      return self.generate(node).asExpr
+    case .genericSpecializationExpr:
+      break
+    case .ifExpr(let node):
+      return self.generate(node).asExpr
+    case .inOutExpr:
+      break
+    case .infixOperatorExpr:
+      break
+    case .integerLiteralExpr(let node):
+      return self.generate(node).asExpr
+    case .isExpr:
+      break
+    case .keyPathExpr:
+      break
+    case .macroExpansionExpr:
+      break
+    case .memberAccessExpr(let node):
+      return self.generate(node).asExpr
+    case .missingExpr:
+      break
+    case .nilLiteralExpr(let node):
+      return self.generate(node).asExpr
+    case .optionalChainingExpr:
+      break
+    case .packElementExpr:
+      break
+    case .packExpansionExpr:
+      break
+    case .patternExpr:
+      break
+    case .postfixIfConfigExpr:
+      break
+    case .postfixOperatorExpr:
+      break
+    case .prefixOperatorExpr:
+      break
+    case .regexLiteralExpr:
+      break
+    case .sequenceExpr:
+      break
+    case .simpleStringLiteralExpr:
+      break
+    case .stringLiteralExpr(let node):
+      return self.generate(node).asExpr
+    case .subscriptCallExpr:
+      break
+    case .superExpr:
+      break
+    case .switchExpr:
+      break
+    case .ternaryExpr:
+      break
+    case .tryExpr:
+      break
+    case .tupleExpr(let node):
+      return self.generate(node).asExpr
+    case .typeExpr:
+      break
+    case .unresolvedAsExpr:
+      break
+    case .unresolvedIsExpr:
+      break
+    case .unresolvedTernaryExpr:
+      break
+    }
+    preconditionFailure("isExprMigrated() mismatch")
+  }
+
   public func generate(_ node: ClosureExprSyntax) -> BridgedClosureExpr {
     let body = BridgedBraceStmt.createParsed(
       self.ctx,
@@ -129,7 +244,7 @@ extension ASTGenVisitor {
       leftParen: node.leftParen,
       rightParen: node.rightParen
     )
-    let callee = generate(node.calledExpression)
+    let callee = generate(expr: node.calledExpression)
 
     return .createParsed(self.ctx, fn: callee, args: argumentTuple)
   }
@@ -140,15 +255,9 @@ 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(node.base!)
+    let base = generate(expr: node.base!)
     let name = node.declName.baseName.bridgedIdentifier(in: self)
 
     return .createParsed(ctx, base: base, dotLoc: loc, name: name, nameLoc: loc)
@@ -177,7 +286,7 @@ extension ASTGenVisitor {
   /// Generate a tuple expression from a ``LabeledExprListSyntax`` and parentheses.
   func generate(_ node: LabeledExprListSyntax, leftParen: TokenSyntax?, rightParen: TokenSyntax?) -> BridgedTupleExpr {
     let expressions = node.lazy.map {
-      self.generate($0.expression)
+      self.generate(expr: $0.expression)
     }
     let labels = node.lazy.map {
       $0.label.bridgedIdentifier(in: self)
diff --git a/lib/ASTGen/Sources/ASTGen/Generics.swift b/lib/ASTGen/Sources/ASTGen/Generics.swift
index 017fbef4b1989..55a5206ad1fea 100644
--- a/lib/ASTGen/Sources/ASTGen/Generics.swift
+++ b/lib/ASTGen/Sources/ASTGen/Generics.swift
@@ -56,15 +56,15 @@ extension ASTGenVisitor {
         return BridgedRequirementRepr(
           SeparatorLoc: conformance.colon.bridgedSourceLoc(in: self),
           Kind: .typeConstraint,
-          FirstType: self.generate(conformance.leftType),
-          SecondType: self.generate(conformance.rightType)
+          FirstType: self.generate(type: conformance.leftType),
+          SecondType: self.generate(type: conformance.rightType)
         )
       case .sameTypeRequirement(let sameType):
         return BridgedRequirementRepr(
           SeparatorLoc: sameType.equal.bridgedSourceLoc(in: self),
           Kind: .sameType,
-          FirstType: self.generate(sameType.leftType),
-          SecondType: self.generate(sameType.rightType)
+          FirstType: self.generate(type: sameType.leftType),
+          SecondType: self.generate(type: sameType.rightType)
         )
       case .layoutRequirement(_):
         // FIXME: Implement layout requirement translation.
diff --git a/lib/ASTGen/Sources/ASTGen/Patterns.swift b/lib/ASTGen/Sources/ASTGen/Patterns.swift
new file mode 100644
index 0000000000000..d2cad631ed7c0
--- /dev/null
+++ b/lib/ASTGen/Sources/ASTGen/Patterns.swift
@@ -0,0 +1,50 @@
+//===--- 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) -> BridgedPattern {
+    switch node.as(PatternSyntaxEnum.self) {
+    case .expressionPattern:
+      break
+    case .identifierPattern(let node):
+      return self.generate(identifierPattern: node).asPattern
+    case .isTypePattern:
+      break
+    case .missingPattern:
+      break
+    case .tuplePattern:
+      break
+    case .valueBindingPattern:
+      break
+    case .wildcardPattern:
+      break
+    }
+
+    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
+    )
+  }
+}
+
+
diff --git a/lib/ASTGen/Sources/ASTGen/Stmts.swift b/lib/ASTGen/Sources/ASTGen/Stmts.swift
index 8ad1fd1a5aaac..4e9c0dad634f2 100644
--- a/lib/ASTGen/Sources/ASTGen/Stmts.swift
+++ b/lib/ASTGen/Sources/ASTGen/Stmts.swift
@@ -11,10 +11,50 @@
 //===----------------------------------------------------------------------===//
 
 import ASTBridging
-import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) import SwiftSyntax
 
 extension ASTGenVisitor {
-  public func generate(_ node: CodeBlockSyntax) -> BridgedBraceStmt {
+  func generate(stmt node: StmtSyntax) -> BridgedStmt {
+    switch node.as(StmtSyntaxEnum.self) {
+    case .breakStmt:
+      break
+    case .continueStmt:
+      break
+    case .deferStmt:
+      break
+    case .discardStmt:
+      break
+    case .doStmt:
+      break
+    case .expressionStmt(let node):
+      return self.generate(node)
+    case .fallThroughStmt:
+      break
+    case .forStmt:
+      break
+    case .guardStmt:
+      break
+    case .labeledStmt:
+      break
+    case .missingStmt:
+      break
+    case .repeatStmt:
+      break
+    case .returnStmt(let node):
+      return self.generate(node).asStmt
+    case .thenStmt:
+      break
+    case .throwStmt:
+      break
+    case .whileStmt:
+      break
+    case .yieldStmt:
+      break
+    }
+    return self.generateWithLegacy(node)
+  }
+
+  public func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {
     BridgedBraceStmt.createParsed(
       self.ctx,
       lBraceLoc: node.leftBrace.bridgedSourceLoc(in: self),
@@ -31,7 +71,7 @@ extension ASTGenVisitor {
       self.ctx,
       ifKeywordLoc: node.ifKeyword.bridgedSourceLoc(in: self),
       condition: conditions.first!.castToExpr,
-      thenStmt: self.generate(node.body).asStmt,
+      thenStmt: self.generate(codeBlock: node.body).asStmt,
       elseLoc: node.elseKeyword.bridgedSourceLoc(in: self),
       elseStmt: (self.generate(node.elseBody)?.castToStmt).asNullable
     )
diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift
index e084769f3a469..ee82c238d5f43 100644
--- a/lib/ASTGen/Sources/ASTGen/Types.swift
+++ b/lib/ASTGen/Sources/ASTGen/Types.swift
@@ -50,8 +50,52 @@ func isTypeMigrated(_ node: TypeSyntax) -> Bool {
   }
 }
 
-
 extension ASTGenVisitor {
+  func generate(type node: TypeSyntax) -> BridgedTypeRepr {
+    guard isTypeMigrated(node) else {
+      return self.generateWithLegacy(node)
+    }
+    switch node.as(TypeSyntaxEnum.self) {
+    case .arrayType(let node):
+      return self.generate(node)
+    case .attributedType(let node):
+      return self.generate(node)
+    case .classRestrictionType:
+      break
+    case .compositionType(let node):
+      return self.generate(node)
+    case .dictionaryType(let node):
+      return self.generate(node)
+    case .functionType(let node):
+      return self.generate(node)
+    case .identifierType(let node):
+      return self.generate(node)
+    case .implicitlyUnwrappedOptionalType(let node):
+      return self.generate(node)
+    case .memberType(let node):
+      return self.generate(node)
+    case .metatypeType(let node):
+      return self.generate(node)
+    case .missingType:
+      break
+    case .namedOpaqueReturnType(let node):
+      return self.generate(node)
+    case .optionalType(let node):
+      return self.generate(node)
+    case .packElementType:
+      break
+    case .packExpansionType(let node):
+      return self.generate(node)
+    case .someOrAnyType(let node):
+      return self.generate(node)
+    case .suppressedType:
+      break
+    case .tupleType(let node):
+      return self.generate(node)
+    }
+    preconditionFailure("isTypeMigrated() mismatch")
+  }
+
   public func generate(_ node: IdentifierTypeSyntax) -> BridgedTypeRepr {
     let loc = node.bridgedSourceLoc(in: self)
 
@@ -67,7 +111,7 @@ extension ASTGenVisitor {
     }
 
     let genericArguments = generics.arguments.lazy.map {
-      self.generate($0.argument)
+      self.generate(type: $0.argument)
     }
 
     return BridgedGenericIdentTypeRepr.createParsed(
@@ -90,7 +134,7 @@ extension ASTGenVisitor {
 
       if let generics = memberType.genericArgumentClause {
         let genericArguments = generics.arguments.lazy.map {
-          self.generate($0.argument)
+          self.generate(type: $0.argument)
         }
 
         reverseMemberComponents.append(
@@ -112,7 +156,7 @@ extension ASTGenVisitor {
       baseType = memberType.baseType
     }
 
-    let baseComponent = generate(baseType)
+    let baseComponent = generate(type: baseType)
     let memberComponents = reverseMemberComponents.reversed().bridgedArray(in: self)
 
     return BridgedMemberTypeRepr.createParsed(
@@ -123,7 +167,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(_ node: ArrayTypeSyntax) -> BridgedTypeRepr {
-    let elementType = generate(node.element)
+    let elementType = generate(type: node.element)
     let lSquareLoc = node.leftSquare.bridgedSourceLoc(in: self)
     let rSquareLoc = node.rightSquare.bridgedSourceLoc(in: self)
     return BridgedArrayTypeRepr.createParsed(
@@ -135,8 +179,8 @@ extension ASTGenVisitor {
   }
 
   public func generate(_ node: DictionaryTypeSyntax) -> BridgedTypeRepr {
-    let keyType = generate(node.key)
-    let valueType = generate(node.value)
+    let keyType = generate(type: node.key)
+    let valueType = generate(type: node.value)
     let colonLoc = node.colon.bridgedSourceLoc(in: self)
     let lSquareLoc = node.leftSquare.bridgedSourceLoc(in: self)
     let rSquareLoc = node.rightSquare.bridgedSourceLoc(in: self)
@@ -151,7 +195,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(_ node: MetatypeTypeSyntax) -> BridgedTypeRepr {
-    let baseType = generate(node.baseType)
+    let baseType = generate(type: node.baseType)
     let tyLoc = node.metatypeSpecifier.bridgedSourceLoc(in: self)
     if node.metatypeSpecifier.text == "Type" {
       return BridgedMetatypeTypeRepr.createParsed(
@@ -170,7 +214,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(_ node: ImplicitlyUnwrappedOptionalTypeSyntax) -> BridgedTypeRepr {
-    let base = generate(node.wrappedType)
+    let base = generate(type: node.wrappedType)
     let exclaimLoc = node.exclamationMark.bridgedSourceLoc(in: self)
     return BridgedImplicitlyUnwrappedOptionalTypeRepr.createParsed(
       self.ctx,
@@ -180,7 +224,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(_ node: OptionalTypeSyntax) -> BridgedTypeRepr {
-    let base = generate(node.wrappedType)
+    let base = generate(type: node.wrappedType)
     let questionLoc = node.questionMark.bridgedSourceLoc(in: self)
     return BridgedOptionalTypeRepr.createParsed(
       self.ctx,
@@ -190,7 +234,7 @@ extension ASTGenVisitor {
   }
 
   public func generate(_ node: PackExpansionTypeSyntax) -> BridgedTypeRepr {
-    let base = generate(node.repetitionPattern)
+    let base = generate(type: node.repetitionPattern)
     let repeatLoc = node.repeatKeyword.bridgedSourceLoc(in: self)
     return BridgedPackExpansionTypeRepr.createParsed(
       self.ctx,
@@ -212,7 +256,7 @@ extension ASTGenVisitor {
     assert(node.elements.count > 1)
 
     let types = node.elements.lazy.map {
-      generate($0.type)
+      generate(type: $0.type)
     }
 
     return BridgedCompositionTypeRepr.createParsed(
@@ -236,18 +280,18 @@ extension ASTGenVisitor {
       throwsLoc: (node.effectSpecifiers?.throwsSpecifier).bridgedSourceLoc(in: self),
       thrownType: self.generate(node.effectSpecifiers?.thrownError?.type).asNullable,
       arrowLoc: node.returnClause.arrow.bridgedSourceLoc(in: self),
-      resultType: generate(node.returnClause.type)
+      resultType: generate(type: node.returnClause.type)
     )
   }
 
   public func generate(_ node: NamedOpaqueReturnTypeSyntax) -> BridgedTypeRepr {
-    let baseTy = generate(node.type)
+    let baseTy = generate(type: node.type)
     return BridgedNamedOpaqueReturnTypeRepr.createParsed(self.ctx, base: baseTy)
   }
 
   public func generate(_ node: SomeOrAnyTypeSyntax) -> BridgedTypeRepr {
     let someOrAnyLoc = node.someOrAnySpecifier.bridgedSourceLoc(in: self)
-    let baseTy = generate(node.constraint)
+    let baseTy = generate(type: node.constraint)
     if node.someOrAnySpecifier.text == "some" {
       return BridgedOpaqueReturnTypeRepr.createParsed(
         self.ctx,
@@ -286,7 +330,7 @@ extension BridgedAttributedTypeSpecifier {
 
 extension ASTGenVisitor {
   public func generate(_ node: AttributedTypeSyntax) -> BridgedTypeRepr {
-    var type = generate(node.baseType)
+    var type = generate(type: node.baseType)
 
     // Handle specifiers.
     if let specifier = node.specifier {
@@ -366,7 +410,7 @@ extension ASTGenVisitor {
     node.lazy.map { element in
       let (firstName, firstNameLoc) = element.firstName.bridgedIdentifierAndSourceLoc(in: self)
       let (secondName, secondNameLoc) = element.secondName.bridgedIdentifierAndSourceLoc(in: self)
-      var type = generate(element.type)
+      var type = generate(type: element.type)
       if let ellipsis = element.ellipsis {
         type = BridgedVarargTypeRepr.createParsed(
           self.ctx,
diff --git a/test/ASTGen/types.swift b/test/ASTGen/types.swift
index 946792c520097..739c0bb14d72e 100644
--- a/test/ASTGen/types.swift
+++ b/test/ASTGen/types.swift
@@ -2,7 +2,8 @@
 
 // -enable-experimental-feature requires an asserts build
 // REQUIRES: asserts
-// REQUIRES: rdar116686158
+// rdar://116686158
+// UNSUPPORTED: asan
 
 protocol P { }
 protocol Q { }
diff --git a/test/ASTGen/verify-parse.swift b/test/ASTGen/verify-parse.swift
index 995c78208887e..e4edffb836459 100644
--- a/test/ASTGen/verify-parse.swift
+++ b/test/ASTGen/verify-parse.swift
@@ -10,7 +10,8 @@
 
 // -enable-experimental-feature requires an asserts build
 // REQUIRES: asserts
-// REQUIRES: rdar116686158
+// rdar://116686158
+// UNSUPPORTED: asan
 
 // NB: Ridiculous formatting to test that we do not include leading trivia in locations.