Merge pull request #556 from CodaFi/label-maker

Formalize Labeled Syntax

Author: CodaFi

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1045,6 +1045,12 @@ extension SyntaxNode {
     return BackDeployVersionArgumentSyntax(asSyntaxData)
   }
 
+  public var isLabeledStmt: Bool { return raw.kind == .labeledStmt }
+  public var asLabeledStmt: LabeledStmtSyntax? {
+    guard isLabeledStmt else { return nil }
+    return LabeledStmtSyntax(asSyntaxData)
+  }
+
   public var isContinueStmt: Bool { return raw.kind == .continueStmt }
   public var asContinueStmt: ContinueStmtSyntax? {
     guard isContinueStmt else { return nil }
@@ -1921,6 +1927,8 @@ extension Syntax {
       return node
     case .backDeployVersionArgument(let node):
       return node
+    case .labeledStmt(let node):
+      return node
     case .continueStmt(let node):
       return node
     case .whileStmt(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1258,6 +1258,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: BackDeployVersionArgumentSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: LabeledStmtSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: LabeledStmtSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: ContinueStmtSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -272,7 +272,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownStmt, .missingStmt, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt:
+    case .unknownStmt, .missingStmt, .labeledStmt, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt:
       self._syntaxNode = syntax
     default:
       return nil
@@ -286,7 +286,7 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownStmt, .missingStmt, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt:
+    case .unknownStmt, .missingStmt, .labeledStmt, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt:
       break
     default:
       fatalError("Unable to create StmtSyntax from \(data.raw.kind)")

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -7275,6 +7275,60 @@ extension BackDeployVersionArgumentSyntax {
   }
 }
 
+public struct LabeledStmtSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 6)
+
+  internal init() {}
+
+  public mutating func useLabelName(_ node: TokenSyntax) {
+    let idx = LabeledStmtSyntax.Cursor.labelName.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useLabelColon(_ node: TokenSyntax) {
+    let idx = LabeledStmtSyntax.Cursor.labelColon.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useStatement(_ node: StmtSyntax) {
+    let idx = LabeledStmtSyntax.Cursor.statement.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.identifier(""))
+    }
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missingToken(TokenKind.colon)
+    }
+    if (layout[5] == nil) {
+      layout[5] = RawSyntax.missing(SyntaxKind.missingStmt)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .labeledStmt,
+      layout: layout, presence: .present))
+  }
+}
+
+extension LabeledStmtSyntax {
+  /// Creates a `LabeledStmtSyntax` 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 `LabeledStmtSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `LabeledStmtSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout LabeledStmtSyntaxBuilder) -> Void) {
+    var builder = LabeledStmtSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct ContinueStmtSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 4)
@@ -7320,20 +7374,10 @@ extension ContinueStmtSyntax {
 
 public struct WhileStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 10)
+    Array<RawSyntax?>(repeating: nil, count: 6)
 
   internal init() {}
 
-  public mutating func useLabelName(_ node: TokenSyntax) {
-    let idx = WhileStmtSyntax.Cursor.labelName.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useLabelColon(_ node: TokenSyntax) {
-    let idx = WhileStmtSyntax.Cursor.labelColon.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useWhileKeyword(_ node: TokenSyntax) {
     let idx = WhileStmtSyntax.Cursor.whileKeyword.rawValue
     layout[idx] = node.raw
@@ -7356,14 +7400,14 @@ public struct WhileStmtSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.whileKeyword)
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.whileKeyword)
     }
-    if (layout[7] == nil) {
-      layout[7] = RawSyntax.missing(SyntaxKind.conditionElementList)
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.conditionElementList)
     }
-    if (layout[9] == nil) {
-      layout[9] = RawSyntax.missing(SyntaxKind.codeBlock)
+    if (layout[5] == nil) {
+      layout[5] = RawSyntax.missing(SyntaxKind.codeBlock)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .whileStmt,
@@ -7474,20 +7518,10 @@ extension ExpressionStmtSyntax {
 
 public struct RepeatWhileStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 12)
+    Array<RawSyntax?>(repeating: nil, count: 8)
 
   internal init() {}
 
-  public mutating func useLabelName(_ node: TokenSyntax) {
-    let idx = RepeatWhileStmtSyntax.Cursor.labelName.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useLabelColon(_ node: TokenSyntax) {
-    let idx = RepeatWhileStmtSyntax.Cursor.labelColon.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useRepeatKeyword(_ node: TokenSyntax) {
     let idx = RepeatWhileStmtSyntax.Cursor.repeatKeyword.rawValue
     layout[idx] = node.raw
@@ -7509,17 +7543,17 @@ public struct RepeatWhileStmtSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.repeatKeyword)
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.repeatKeyword)
     }
-    if (layout[7] == nil) {
-      layout[7] = RawSyntax.missing(SyntaxKind.codeBlock)
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.codeBlock)
     }
-    if (layout[9] == nil) {
-      layout[9] = RawSyntax.missingToken(TokenKind.whileKeyword)
+    if (layout[5] == nil) {
+      layout[5] = RawSyntax.missingToken(TokenKind.whileKeyword)
     }
-    if (layout[11] == nil) {
-      layout[11] = RawSyntax.missing(SyntaxKind.missingExpr)
+    if (layout[7] == nil) {
+      layout[7] = RawSyntax.missing(SyntaxKind.missingExpr)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .repeatWhileStmt,
@@ -7660,20 +7694,10 @@ extension WhereClauseSyntax {
 
 public struct ForInStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 24)
+    Array<RawSyntax?>(repeating: nil, count: 20)
 
   internal init() {}
 
-  public mutating func useLabelName(_ node: TokenSyntax) {
-    let idx = ForInStmtSyntax.Cursor.labelName.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useLabelColon(_ node: TokenSyntax) {
-    let idx = ForInStmtSyntax.Cursor.labelColon.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useForKeyword(_ node: TokenSyntax) {
     let idx = ForInStmtSyntax.Cursor.forKeyword.rawValue
     layout[idx] = node.raw
@@ -7725,20 +7749,20 @@ public struct ForInStmtSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.forKeyword)
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.forKeyword)
+    }
+    if (layout[9] == nil) {
+      layout[9] = RawSyntax.missing(SyntaxKind.missingPattern)
     }
     if (layout[13] == nil) {
-      layout[13] = RawSyntax.missing(SyntaxKind.missingPattern)
+      layout[13] = RawSyntax.missingToken(TokenKind.inKeyword)
     }
-    if (layout[17] == nil) {
-      layout[17] = RawSyntax.missingToken(TokenKind.inKeyword)
+    if (layout[15] == nil) {
+      layout[15] = RawSyntax.missing(SyntaxKind.missingExpr)
     }
     if (layout[19] == nil) {
-      layout[19] = RawSyntax.missing(SyntaxKind.missingExpr)
-    }
-    if (layout[23] == nil) {
-      layout[23] = RawSyntax.missing(SyntaxKind.codeBlock)
+      layout[19] = RawSyntax.missing(SyntaxKind.codeBlock)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .forInStmt,
@@ -7765,20 +7789,10 @@ extension ForInStmtSyntax {
 
 public struct SwitchStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 14)
+    Array<RawSyntax?>(repeating: nil, count: 10)
 
   internal init() {}
 
-  public mutating func useLabelName(_ node: TokenSyntax) {
-    let idx = SwitchStmtSyntax.Cursor.labelName.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useLabelColon(_ node: TokenSyntax) {
-    let idx = SwitchStmtSyntax.Cursor.labelColon.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useSwitchKeyword(_ node: TokenSyntax) {
     let idx = SwitchStmtSyntax.Cursor.switchKeyword.rawValue
     layout[idx] = node.raw
@@ -7811,20 +7825,20 @@ public struct SwitchStmtSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.switchKeyword)
+    }
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.missingExpr)
+    }
     if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.switchKeyword)
+      layout[5] = RawSyntax.missingToken(TokenKind.leftBrace)
     }
     if (layout[7] == nil) {
-      layout[7] = RawSyntax.missing(SyntaxKind.missingExpr)
+      layout[7] = RawSyntax.missing(SyntaxKind.switchCaseList)
     }
     if (layout[9] == nil) {
-      layout[9] = RawSyntax.missingToken(TokenKind.leftBrace)
-    }
-    if (layout[11] == nil) {
-      layout[11] = RawSyntax.missing(SyntaxKind.switchCaseList)
-    }
-    if (layout[13] == nil) {
-      layout[13] = RawSyntax.missingToken(TokenKind.rightBrace)
+      layout[9] = RawSyntax.missingToken(TokenKind.rightBrace)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .switchStmt,
@@ -7851,20 +7865,10 @@ extension SwitchStmtSyntax {
 
 public struct DoStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 10)
+    Array<RawSyntax?>(repeating: nil, count: 6)
 
   internal init() {}
 
-  public mutating func useLabelName(_ node: TokenSyntax) {
-    let idx = DoStmtSyntax.Cursor.labelName.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useLabelColon(_ node: TokenSyntax) {
-    let idx = DoStmtSyntax.Cursor.labelColon.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useDoKeyword(_ node: TokenSyntax) {
     let idx = DoStmtSyntax.Cursor.doKeyword.rawValue
     layout[idx] = node.raw
@@ -7887,11 +7891,11 @@ public struct DoStmtSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.doKeyword)
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.doKeyword)
     }
-    if (layout[7] == nil) {
-      layout[7] = RawSyntax.missing(SyntaxKind.codeBlock)
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.codeBlock)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .doStmt,
@@ -8531,20 +8535,10 @@ extension ThrowStmtSyntax {
 
 public struct IfStmtSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 14)
+    Array<RawSyntax?>(repeating: nil, count: 10)
 
   internal init() {}
 
-  public mutating func useLabelName(_ node: TokenSyntax) {
-    let idx = IfStmtSyntax.Cursor.labelName.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useLabelColon(_ node: TokenSyntax) {
-    let idx = IfStmtSyntax.Cursor.labelColon.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useIfKeyword(_ node: TokenSyntax) {
     let idx = IfStmtSyntax.Cursor.ifKeyword.rawValue
     layout[idx] = node.raw
@@ -8577,14 +8571,14 @@ public struct IfStmtSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.ifKeyword)
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.ifKeyword)
     }
-    if (layout[7] == nil) {
-      layout[7] = RawSyntax.missing(SyntaxKind.conditionElementList)
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.conditionElementList)
     }
-    if (layout[9] == nil) {
-      layout[9] = RawSyntax.missing(SyntaxKind.codeBlock)
+    if (layout[5] == nil) {
+      layout[5] = RawSyntax.missing(SyntaxKind.codeBlock)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .ifStmt,

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -79,7 +79,7 @@ extension SyntaxClassification {
         return (.keyword, false)
       case (.attribute, 3):
         return (.attribute, false)
-      case (.forInStmt, 9):
+      case (.forInStmt, 5):
         return (.keyword, false)
       case (.simpleTypeIdentifier, 1):
         return (.typeIdentifier, false)