Merge pull request #347 from hamishknight/pitter-patter

Author: hamishknight

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -433,6 +433,12 @@ extension SyntaxNode {
     return StringLiteralExprSyntax(asSyntaxData)
   }
 
+  public var isRegexLiteralExpr: Bool { return raw.kind == .regexLiteralExpr }
+  public var asRegexLiteralExpr: RegexLiteralExprSyntax? {
+    guard isRegexLiteralExpr else { return nil }
+    return RegexLiteralExprSyntax(asSyntaxData)
+  }
+
   public var isKeyPathExpr: Bool { return raw.kind == .keyPathExpr }
   public var asKeyPathExpr: KeyPathExprSyntax? {
     guard isKeyPathExpr else { return nil }
@@ -1625,6 +1631,8 @@ extension Syntax {
       return node
     case .stringLiteralExpr(let node):
       return node
+    case .regexLiteralExpr(let node):
+      return node
     case .keyPathExpr(let node):
       return node
     case .keyPathBaseExpr(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -547,6 +547,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: StringLiteralExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: RegexLiteralExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: RegexLiteralExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: KeyPathExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -164,7 +164,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       self._syntaxNode = syntax
     default:
       return nil
@@ -178,7 +178,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .ternaryExpr, .memberAccessExpr, .isExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .keyPathBaseExpr, .objcKeyPathExpr, .objcSelectorExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -2673,6 +2673,44 @@ extension StringLiteralExprSyntax {
   }
 }
 
+public struct RegexLiteralExprSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 1)
+
+  internal init() {}
+
+  public mutating func useRegex(_ node: TokenSyntax) {
+    let idx = RegexLiteralExprSyntax.Cursor.regex.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.regexLiteral(""))
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .regexLiteralExpr,
+      layout: layout, presence: .present))
+  }
+}
+
+extension RegexLiteralExprSyntax {
+  /// Creates a `RegexLiteralExprSyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that will be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `RegexLiteralExprSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `RegexLiteralExprSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout RegexLiteralExprSyntaxBuilder) -> Void) {
+    var builder = RegexLiteralExprSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct KeyPathExprSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 3)

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -342,6 +342,8 @@ extension RawTokenKind {
       return .floatingLiteral
     case .stringLiteral:
       return .stringLiteral
+    case .regexLiteral:
+      return .none
     case .unknown:
       return .none
     case .identifier:

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -90,6 +90,7 @@ public enum SyntaxEnum {
   case stringSegment(StringSegmentSyntax)
   case expressionSegment(ExpressionSegmentSyntax)
   case stringLiteralExpr(StringLiteralExprSyntax)
+  case regexLiteralExpr(RegexLiteralExprSyntax)
   case keyPathExpr(KeyPathExprSyntax)
   case keyPathBaseExpr(KeyPathBaseExprSyntax)
   case objcNamePiece(ObjcNamePieceSyntax)
@@ -419,6 +420,8 @@ public extension Syntax {
       return .expressionSegment(ExpressionSegmentSyntax(self)!)
     case .stringLiteralExpr:
       return .stringLiteralExpr(StringLiteralExprSyntax(self)!)
+    case .regexLiteralExpr:
+      return .regexLiteralExpr(RegexLiteralExprSyntax(self)!)
     case .keyPathExpr:
       return .keyPathExpr(KeyPathExprSyntax(self)!)
     case .keyPathBaseExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -1297,6 +1297,23 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return StringLiteralExprSyntax(data)
   }
+  public static func makeRegexLiteralExpr(regex: TokenSyntax) -> RegexLiteralExprSyntax {
+    let layout: [RawSyntax?] = [
+      regex.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.regexLiteralExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return RegexLiteralExprSyntax(data)
+  }
+
+  public static func makeBlankRegexLiteralExpr() -> RegexLiteralExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .regexLiteralExpr,
+      layout: [
+      RawSyntax.missingToken(TokenKind.regexLiteral("")),
+    ], length: .zero, presence: .present))
+    return RegexLiteralExprSyntax(data)
+  }
   public static func makeKeyPathExpr(backslash: TokenSyntax, rootExpr: ExprSyntax?, expression: ExprSyntax) -> KeyPathExprSyntax {
     let layout: [RawSyntax?] = [
       backslash.raw,
@@ -5516,6 +5533,12 @@ public enum SyntaxFactory {
                      leadingTrivia: leadingTrivia,
                      trailingTrivia: trailingTrivia)
   }
+  public static func makeRegexLiteral(_ text: String,
+    leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
+    return makeToken(.regexLiteral(text), presence: .present,
+                     leadingTrivia: leadingTrivia,
+                     trailingTrivia: trailingTrivia)
+  }
   public static func makeUnknown(_ text: String,
     leadingTrivia: Trivia = [], trailingTrivia: Trivia = []) -> TokenSyntax {
     return makeToken(.unknown(text), presence: .present,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -90,6 +90,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case stringSegment = 104
   case expressionSegment = 105
   case stringLiteralExpr = 48
+  case regexLiteralExpr = 253
   case keyPathExpr = 65
   case keyPathBaseExpr = 66
   case objcNamePiece = 106

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -506,6 +506,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `RegexLiteralExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: RegexLiteralExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `KeyPathExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2484,6 +2491,16 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplRegexLiteralExprSyntax(_ data: SyntaxData) -> Syntax {
+      let node = RegexLiteralExprSyntax(data)
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
+      return Syntax(visit(node))
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplKeyPathExprSyntax(_ data: SyntaxData) -> Syntax {
       let node = KeyPathExprSyntax(data)
@@ -4394,6 +4411,8 @@ open class SyntaxRewriter {
       return visitImplExpressionSegmentSyntax
     case .stringLiteralExpr:
       return visitImplStringLiteralExprSyntax
+    case .regexLiteralExpr:
+      return visitImplRegexLiteralExprSyntax
     case .keyPathExpr:
       return visitImplKeyPathExprSyntax
     case .keyPathBaseExpr:
@@ -4899,6 +4918,8 @@ open class SyntaxRewriter {
       return visitImplExpressionSegmentSyntax(data)
     case .stringLiteralExpr:
       return visitImplStringLiteralExprSyntax(data)
+    case .regexLiteralExpr:
+      return visitImplRegexLiteralExprSyntax(data)
     case .keyPathExpr:
       return visitImplKeyPathExprSyntax(data)
     case .keyPathBaseExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -722,6 +722,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `StringLiteralExprSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: StringLiteralExprSyntax) {}
+  /// Visiting `RegexLiteralExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: RegexLiteralExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `RegexLiteralExprSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: RegexLiteralExprSyntax) {}
   /// Visiting `KeyPathExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -3269,6 +3279,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplRegexLiteralExprSyntax(_ data: SyntaxData) {
+      let node = RegexLiteralExprSyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && node.raw.numberOfChildren > 0 {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplKeyPathExprSyntax(_ data: SyntaxData) {
       let node = KeyPathExprSyntax(data)
@@ -5318,6 +5339,8 @@ open class SyntaxVisitor {
       visitImplExpressionSegmentSyntax(data)
     case .stringLiteralExpr:
       visitImplStringLiteralExprSyntax(data)
+    case .regexLiteralExpr:
+      visitImplRegexLiteralExprSyntax(data)
     case .keyPathExpr:
       visitImplKeyPathExprSyntax(data)
     case .keyPathBaseExpr: