Merge pull request #185 from brentdax/file-name-basis

SwiftSyntax update for "Shorten #file and add #filePath (behind an experimental flag)" (swiftlang/swift#25656)

Author: beccadax

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -183,6 +183,12 @@ extension SyntaxNode {
     return PoundFileExprSyntax(asSyntaxData)
   }
 
+  public var isPoundFilePathExpr: Bool { return raw.kind == .poundFilePathExpr }
+  public var asPoundFilePathExpr: PoundFilePathExprSyntax? {
+    guard isPoundFilePathExpr else { return nil }
+    return PoundFilePathExprSyntax(asSyntaxData)
+  }
+
   public var isPoundFunctionExpr: Bool { return raw.kind == .poundFunctionExpr }
   public var asPoundFunctionExpr: PoundFunctionExprSyntax? {
     guard isPoundFunctionExpr else { return nil }
@@ -1471,6 +1477,8 @@ extension Syntax {
       return node
     case .poundFileExpr(let node):
       return node
+    case .poundFilePathExpr(let node):
+      return node
     case .poundFunctionExpr(let node):
       return node
     case .poundDsohandleExpr(let node):
@@ -1880,6 +1888,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "3924247553615556843"
+      "7184602491276114819"
   }
 }

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: PoundFilePathExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: PoundFilePathExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: PoundFunctionExprSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -146,7 +146,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, .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, .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
@@ -160,7 +160,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, .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, .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 PoundFilePathExprSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 1)
+
+  internal init() {}
+
+  public mutating func usePoundFilePath(_ node: TokenSyntax) {
+    let idx = PoundFilePathExprSyntax.Cursor.poundFilePath.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.poundFilePathKeyword)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .poundFilePathExpr,
+      layout: layout, presence: .present))
+  }
+}
+
+extension PoundFilePathExprSyntax {
+  /// Creates a `PoundFilePathExprSyntax` 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 `PoundFilePathExprSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `PoundFilePathExprSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout PoundFilePathExprSyntaxBuilder) -> Void) {
+    var builder = PoundFilePathExprSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct PoundFunctionExprSyntaxBuilder {
   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 .poundFilePathKeyword:
+      return .keyword
     case .poundColumnKeyword:
       return .keyword
     case .poundFunctionKeyword:

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

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

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -456,6 +456,23 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return PoundFileExprSyntax(data)
   }
+  public static func makePoundFilePathExpr(poundFilePath: TokenSyntax) -> PoundFilePathExprSyntax {
+    let layout: [RawSyntax?] = [
+      poundFilePath.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.poundFilePathExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return PoundFilePathExprSyntax(data)
+  }
+
+  public static func makeBlankPoundFilePathExpr() -> PoundFilePathExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .poundFilePathExpr,
+      layout: [
+      RawSyntax.missingToken(TokenKind.poundFilePathKeyword),
+    ], length: .zero, presence: .present))
+    return PoundFilePathExprSyntax(data)
+  }
   public static func makePoundFunctionExpr(poundFunction: TokenSyntax) -> PoundFunctionExprSyntax {
     let layout: [RawSyntax?] = [
       poundFunction.raw,
@@ -5130,6 +5147,12 @@ public enum SyntaxFactory {
                      leadingTrivia: leadingTrivia,
                      trailingTrivia: trailingTrivia)
   }
+  public static func makePoundFilePathKeyword(leadingTrivia: Trivia = [],
+    trailingTrivia: Trivia = []) -> TokenSyntax {
+    return makeToken(.poundFilePathKeyword, presence: .present,
+                     leadingTrivia: leadingTrivia,
+                     trailingTrivia: trailingTrivia)
+  }
   public static func makePoundColumnKeyword(leadingTrivia: Trivia = [],
     trailingTrivia: Trivia = []) -> TokenSyntax {
     return makeToken(.poundColumnKeyword, 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 poundFilePathExpr = 240
   case poundFunctionExpr = 36
   case poundDsohandleExpr = 37
   case symbolicReferenceExpr = 38

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

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

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