Merge pull request #226 from brentdax/magical-and-evolutionary

Add syntax nodes for #fileID

Author: beccadax

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -183,6 +183,12 @@ extension SyntaxNode {
     return PoundFileExprSyntax(asSyntaxData)
   }
 
+  public var isPoundFileIDExpr: Bool { return raw.kind == .poundFileIDExpr }
+  public var asPoundFileIDExpr: PoundFileIDExprSyntax? {
+    guard isPoundFileIDExpr else { return nil }
+    return PoundFileIDExprSyntax(asSyntaxData)
+  }
+
   public var isPoundFilePathExpr: Bool { return raw.kind == .poundFilePathExpr }
   public var asPoundFilePathExpr: PoundFilePathExprSyntax? {
     guard isPoundFilePathExpr else { return nil }
@@ -1507,6 +1513,8 @@ extension Syntax {
       return node
     case .poundFileExpr(let node):
       return node
+    case .poundFileIDExpr(let node):
+      return node
     case .poundFilePathExpr(let node):
       return node
     case .poundFunctionExpr(let node):
@@ -1928,6 +1936,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "7b2f9ca5e9d7140a7fadb9bb5da4f23b1836bdf3"
+      "77e9551aa9f94761b9808f610830fa826cc8323a"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -253,6 +253,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: PoundFileExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: PoundFileIDExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: PoundFileIDExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: PoundFilePathExprSyntax) -> 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, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .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, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .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, .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, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .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, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .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, .editorPlaceholderExpr, .objectLiteralExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

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

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -286,6 +286,8 @@ extension RawTokenKind {
       return .keyword
     case .poundFileKeyword:
       return .keyword
+    case .poundFileIDKeyword:
+      return .keyword
     case .poundFilePathKeyword:
       return .keyword
     case .poundColumnKeyword:

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -48,6 +48,7 @@ public enum SyntaxEnum {
   case exprList(ExprListSyntax)
   case poundLineExpr(PoundLineExprSyntax)
   case poundFileExpr(PoundFileExprSyntax)
+  case poundFileIDExpr(PoundFileIDExprSyntax)
   case poundFilePathExpr(PoundFilePathExprSyntax)
   case poundFunctionExpr(PoundFunctionExprSyntax)
   case poundDsohandleExpr(PoundDsohandleExprSyntax)
@@ -329,6 +330,8 @@ public extension Syntax {
       return .poundLineExpr(PoundLineExprSyntax(self)!)
     case .poundFileExpr:
       return .poundFileExpr(PoundFileExprSyntax(self)!)
+    case .poundFileIDExpr:
+      return .poundFileIDExpr(PoundFileIDExprSyntax(self)!)
     case .poundFilePathExpr:
       return .poundFilePathExpr(PoundFilePathExprSyntax(self)!)
     case .poundFunctionExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -456,6 +456,23 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return PoundFileExprSyntax(data)
   }
+  public static func makePoundFileIDExpr(poundFileID: TokenSyntax) -> PoundFileIDExprSyntax {
+    let layout: [RawSyntax?] = [
+      poundFileID.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundFileIDExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return PoundFileIDExprSyntax(data)
+  }
+
+  public static func makeBlankPoundFileIDExpr() -> PoundFileIDExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundFileIDExpr,
+      layout: [
+      RawSyntax.missingToken(TokenKind.poundFileIDKeyword),
+    ], length: .zero, presence: .present))
+    return PoundFileIDExprSyntax(data)
+  }
   public static func makePoundFilePathExpr(poundFilePath: TokenSyntax) -> PoundFilePathExprSyntax {
     let layout: [RawSyntax?] = [
       poundFilePath.raw,
@@ -5244,6 +5261,12 @@ public enum SyntaxFactory {
                      leadingTrivia: leadingTrivia,
                      trailingTrivia: trailingTrivia)
   }
+  public static func makePoundFileIDKeyword(leadingTrivia: Trivia = [],
+    trailingTrivia: Trivia = []) -> TokenSyntax {
+    return makeToken(.poundFileIDKeyword, presence: .present,
+                     leadingTrivia: leadingTrivia,
+                     trailingTrivia: trailingTrivia)
+  }
   public static func makePoundFilePathKeyword(leadingTrivia: Trivia = [],
     trailingTrivia: Trivia = []) -> TokenSyntax {
     return makeToken(.poundFilePathKeyword, presence: .present,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -48,6 +48,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case exprList = 170
   case poundLineExpr = 34
   case poundFileExpr = 35
+  case poundFileIDExpr = 247
   case poundFilePathExpr = 240
   case poundFunctionExpr = 36
   case poundDsohandleExpr = 37

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -212,6 +212,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `PoundFileIDExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: PoundFileIDExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `PoundFilePathExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2022,6 +2029,16 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplPoundFileIDExprSyntax(_ data: SyntaxData) -> Syntax {
+      let node = PoundFileIDExprSyntax(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 visitImplPoundFilePathExprSyntax(_ data: SyntaxData) -> Syntax {
       let node = PoundFilePathExprSyntax(data)
@@ -4208,6 +4225,8 @@ open class SyntaxRewriter {
       return visitImplPoundLineExprSyntax
     case .poundFileExpr:
       return visitImplPoundFileExprSyntax
+    case .poundFileIDExpr:
+      return visitImplPoundFileIDExprSyntax
     case .poundFilePathExpr:
       return visitImplPoundFilePathExprSyntax
     case .poundFunctionExpr:
@@ -4701,6 +4720,8 @@ open class SyntaxRewriter {
       return visitImplPoundLineExprSyntax(data)
     case .poundFileExpr:
       return visitImplPoundFileExprSyntax(data)
+    case .poundFileIDExpr:
+      return visitImplPoundFileIDExprSyntax(data)
     case .poundFilePathExpr:
       return visitImplPoundFilePathExprSyntax(data)
     case .poundFunctionExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -302,6 +302,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `PoundFileExprSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: PoundFileExprSyntax) {}
+  /// Visiting `PoundFileIDExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: PoundFileIDExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `PoundFileIDExprSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: PoundFileIDExprSyntax) {}
   /// Visiting `PoundFilePathExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -2747,6 +2757,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplPoundFileIDExprSyntax(_ data: SyntaxData) {
+      let node = PoundFileIDExprSyntax(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 visitImplPoundFilePathExprSyntax(_ data: SyntaxData) {
       let node = PoundFilePathExprSyntax(data)
@@ -5108,6 +5129,8 @@ open class SyntaxVisitor {
       visitImplPoundLineExprSyntax(data)
     case .poundFileExpr:
       visitImplPoundFileExprSyntax(data)
+    case .poundFileIDExpr:
+      visitImplPoundFileIDExprSyntax(data)
     case .poundFilePathExpr:
       visitImplPoundFilePathExprSyntax(data)
     case .poundFunctionExpr: