[ASTGen] Implement patterns

Except `MissingPatternSyntax`

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -1121,6 +1121,16 @@ BridgedBindingPattern_createParsed(BridgedASTContext cContext,
                                    BridgedSourceLoc cKeywordLoc, bool isLet,
                                    BridgedPattern cSubPattern);
 
+SWIFT_NAME("BridgedExprPattern.createParsed(_:expr:)")
+BridgedExprPattern
+BridgedExprPattern_createParsed(BridgedDeclContext cDeclContext,
+                                BridgedExpr cExpr);
+
+SWIFT_NAME("BridgedIsPattern.createParsed(_:isLoc:typeExpr:)")
+BridgedIsPattern BridgedIsPattern_createParsed(BridgedASTContext cContext,
+                                               BridgedSourceLoc cIsLoc,
+                                               BridgedTypeExpr cTypeExpr);
+
 SWIFT_NAME("BridgedNamedPattern.createParsed(_:declContext:name:loc:)")
 BridgedNamedPattern
 BridgedNamedPattern_createParsed(BridgedASTContext astContext,

lib/AST/ASTBridging.cpp

@@ -1553,6 +1553,22 @@ BridgedBindingPattern_createParsed(BridgedASTContext cContext,
       cKeywordLoc.unbridged(), introducer, cSubPattern.unbridged());
 }
 
+BridgedExprPattern
+BridgedExprPattern_createParsed(BridgedDeclContext cDeclContext,
+                                BridgedExpr cExpr) {
+  auto *DC = cDeclContext.unbridged();
+  auto &context = DC->getASTContext();
+  return ExprPattern::createParsed(context, cExpr.unbridged(), DC);
+}
+
+BridgedIsPattern BridgedIsPattern_createParsed(BridgedASTContext cContext,
+                                               BridgedSourceLoc cIsLoc,
+                                               BridgedTypeExpr cTypeExpr) {
+  return new (cContext.unbridged())
+      IsPattern(cIsLoc.unbridged(), cTypeExpr.unbridged(),
+                /*subPattern=*/nullptr, CheckedCastKind::Unresolved);
+}
+
 BridgedNamedPattern
 BridgedNamedPattern_createParsed(BridgedASTContext cContext,
                                  BridgedDeclContext cDeclContext,

lib/ASTGen/Sources/ASTGen/Patterns.swift

@@ -18,23 +18,28 @@ import SwiftDiagnostics
 extension ASTGenVisitor {
   func generate(pattern node: PatternSyntax) -> BridgedPattern {
     switch node.as(PatternSyntaxEnum.self) {
-    case .expressionPattern:
-      break
+    case .expressionPattern(let node):
+      return self.generate(expressionPattern: node).asPattern
     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
+    case .isTypePattern(let node):
+      return self.generate(isTypePattern: node).asPattern
+    case .missingPattern(let node):
+      return self.generate(missingPattern: node)
+    case .tuplePattern(let node):
+      return self.generate(tuplePattern: node)
+    case .valueBindingPattern(let node):
+      return self.generate(valueBindingPattern: node).asPattern
+    case .wildcardPattern(let node):
+      return self.generate(wildcardPattern: node).asPattern
     }
+  }
 
-    preconditionFailure("unimplemented")
+  func generate(expressionPattern node: ExpressionPatternSyntax) -> BridgedExprPattern {
+    return .createParsed(
+      self.declContext,
+      expr: self.generate(expr: node.expression)
+    )
   }
 
   func generate(identifierPattern node: IdentifierPatternSyntax) -> BridgedNamedPattern {
@@ -45,6 +50,60 @@ extension ASTGenVisitor {
       loc: nameLoc
     )
   }
+
+  func generate(isTypePattern node: IsTypePatternSyntax) -> BridgedIsPattern {
+    return .createParsed(
+      self.ctx,
+      isLoc: self.generateSourceLoc(node.isKeyword),
+      typeExpr: .createParsed(
+        self.ctx,
+        type: self.generate(type: node.type)
+      )
+    )
+  }
+
+  func generate(missingPattern node: MissingPatternSyntax) -> BridgedPattern {
+    fatalError("unimplemented")
+  }
+
+  func generate(tuplePattern node: TuplePatternSyntax) -> BridgedPattern {
+    if node.elements.count == 1, let firstElement = node.elements.first, firstElement.label == nil {
+      return BridgedParenPattern.createParsed(
+        self.ctx,
+        lParenLoc: self.generateSourceLoc(node.leftParen),
+        subPattern: self.generate(pattern: firstElement.pattern),
+        rParenLoc: self.generateSourceLoc(node.rightParen)
+      ).asPattern
+    }
+    return BridgedTuplePattern.createParsed(
+      self.ctx,
+      lParenLoc: self.generateSourceLoc(node.leftParen),
+      elements: node.elements.lazy.map {
+        BridgedTuplePatternElt(
+          Label: self.generateIdentifier($0.label),
+          LabelLoc: self.generateSourceLoc($0.label),
+          ThePattern: self.generate(pattern: $0.pattern)
+        )
+      }.bridgedArray(in: self),
+      rParenLoc: self.generateSourceLoc(node.rightParen)
+    ).asPattern
+  }
+
+  func generate(valueBindingPattern node: ValueBindingPatternSyntax) -> BridgedBindingPattern {
+    return .createParsed(
+      self.ctx,
+      keywordLoc: self.generateSourceLoc(node.bindingSpecifier),
+      isLet: node.bindingSpecifier.keywordKind == .let,
+      subPattern: self.generate(pattern: node.pattern)
+    )
+  }
+
+  func generate(wildcardPattern node: WildcardPatternSyntax) -> BridgedAnyPattern {
+    return .createParsed(
+      self.ctx,
+      loc: self.generateSourceLoc(node.wildcard)
+    )
+  }
 }