Regenerate with InfixOperatorExpr.

Author: DougGregor

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -277,6 +277,12 @@ extension SyntaxNode {
     return ArrowExprSyntax(asSyntaxData)
   }
 
+  public var isInfixOperatorExpr: Bool { return raw.kind == .infixOperatorExpr }
+  public var asInfixOperatorExpr: InfixOperatorExprSyntax? {
+    guard isInfixOperatorExpr else { return nil }
+    return InfixOperatorExprSyntax(asSyntaxData)
+  }
+
   public var isFloatLiteralExpr: Bool { return raw.kind == .floatLiteralExpr }
   public var asFloatLiteralExpr: FloatLiteralExprSyntax? {
     guard isFloatLiteralExpr else { return nil }
@@ -1665,6 +1671,8 @@ extension Syntax {
       return node
     case .arrowExpr(let node):
       return node
+    case .infixOperatorExpr(let node):
+      return node
     case .floatLiteralExpr(let node):
       return node
     case .tupleExpr(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -362,6 +362,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: ArrowExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: InfixOperatorExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: FloatLiteralExprSyntax) -> 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, .missingExpr, .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:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .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, .missingExpr, .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:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .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

@@ -1047,6 +1047,60 @@ extension ArrowExprSyntax {
   }
 }
 
+public struct InfixOperatorExprSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 6)
+
+  internal init() {}
+
+  public mutating func useLeftOperand(_ node: ExprSyntax) {
+    let idx = InfixOperatorExprSyntax.Cursor.leftOperand.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useOperatorOperand(_ node: ExprSyntax) {
+    let idx = InfixOperatorExprSyntax.Cursor.operatorOperand.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useRightOperand(_ node: ExprSyntax) {
+    let idx = InfixOperatorExprSyntax.Cursor.rightOperand.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missing(SyntaxKind.missingExpr)
+    }
+    if (layout[3] == nil) {
+      layout[3] = RawSyntax.missing(SyntaxKind.missingExpr)
+    }
+    if (layout[5] == nil) {
+      layout[5] = RawSyntax.missing(SyntaxKind.missingExpr)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .infixOperatorExpr,
+      layout: layout, presence: .present))
+  }
+}
+
+extension InfixOperatorExprSyntax {
+  /// Creates a `InfixOperatorExprSyntax` 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 `InfixOperatorExprSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `InfixOperatorExprSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout InfixOperatorExprSyntaxBuilder) -> Void) {
+    var builder = InfixOperatorExprSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct FloatLiteralExprSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 2)

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -59,6 +59,7 @@ public enum SyntaxEnum {
   case prefixOperatorExpr(PrefixOperatorExprSyntax)
   case binaryOperatorExpr(BinaryOperatorExprSyntax)
   case arrowExpr(ArrowExprSyntax)
+  case infixOperatorExpr(InfixOperatorExprSyntax)
   case floatLiteralExpr(FloatLiteralExprSyntax)
   case tupleExpr(TupleExprSyntax)
   case arrayExpr(ArrayExprSyntax)
@@ -369,6 +370,8 @@ public extension Syntax {
       return .binaryOperatorExpr(BinaryOperatorExprSyntax(self)!)
     case .arrowExpr:
       return .arrowExpr(ArrowExprSyntax(self)!)
+    case .infixOperatorExpr:
+      return .infixOperatorExpr(InfixOperatorExprSyntax(self)!)
     case .floatLiteralExpr:
       return .floatLiteralExpr(FloatLiteralExprSyntax(self)!)
     case .tupleExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -755,6 +755,33 @@ public enum SyntaxFactory {
     ], length: .zero, presence: presence))
     return ArrowExprSyntax(data)
   }
+  public static func makeInfixOperatorExpr(_ garbageBeforeLeftOperand: GarbageNodesSyntax? = nil, leftOperand: ExprSyntax, _ garbageBetweenLeftOperandAndOperatorOperand: GarbageNodesSyntax? = nil, operatorOperand: ExprSyntax, _ garbageBetweenOperatorOperandAndRightOperand: GarbageNodesSyntax? = nil, rightOperand: ExprSyntax) -> InfixOperatorExprSyntax {
+    let layout: [RawSyntax?] = [
+      garbageBeforeLeftOperand?.raw,
+      leftOperand.raw,
+      garbageBetweenLeftOperandAndOperatorOperand?.raw,
+      operatorOperand.raw,
+      garbageBetweenOperatorOperandAndRightOperand?.raw,
+      rightOperand.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.infixOperatorExpr,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return InfixOperatorExprSyntax(data)
+  }
+
+  public static func makeBlankInfixOperatorExpr(presence: SourcePresence = .present) -> InfixOperatorExprSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .infixOperatorExpr,
+      layout: [
+      nil,
+      RawSyntax.missing(SyntaxKind.missingExpr),
+      nil,
+      RawSyntax.missing(SyntaxKind.missingExpr),
+      nil,
+      RawSyntax.missing(SyntaxKind.missingExpr),
+    ], length: .zero, presence: presence))
+    return InfixOperatorExprSyntax(data)
+  }
   public static func makeFloatLiteralExpr(_ garbageBeforeFloatingDigits: GarbageNodesSyntax? = nil, floatingDigits: TokenSyntax) -> FloatLiteralExprSyntax {
     let layout: [RawSyntax?] = [
       garbageBeforeFloatingDigits?.raw,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -59,6 +59,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case prefixOperatorExpr = 39
   case binaryOperatorExpr = 40
   case arrowExpr = 41
+  case infixOperatorExpr = 267
   case floatLiteralExpr = 42
   case tupleExpr = 43
   case arrayExpr = 44

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -324,6 +324,13 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
+  /// Visit a `InfixOperatorExprSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: InfixOperatorExprSyntax) -> ExprSyntax {
+    return ExprSyntax(visitChildren(node))
+  }
+
   /// Visit a `FloatLiteralExprSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2343,6 +2350,16 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplInfixOperatorExprSyntax(_ data: SyntaxData) -> Syntax {
+      let node = InfixOperatorExprSyntax(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 visitImplFloatLiteralExprSyntax(_ data: SyntaxData) -> Syntax {
       let node = FloatLiteralExprSyntax(data)
@@ -4621,6 +4638,8 @@ open class SyntaxRewriter {
       return visitImplBinaryOperatorExprSyntax
     case .arrowExpr:
       return visitImplArrowExprSyntax
+    case .infixOperatorExpr:
+      return visitImplInfixOperatorExprSyntax
     case .floatLiteralExpr:
       return visitImplFloatLiteralExprSyntax
     case .tupleExpr:
@@ -5150,6 +5169,8 @@ open class SyntaxRewriter {
       return visitImplBinaryOperatorExprSyntax(data)
     case .arrowExpr:
       return visitImplArrowExprSyntax(data)
+    case .infixOperatorExpr:
+      return visitImplInfixOperatorExprSyntax(data)
     case .floatLiteralExpr:
       return visitImplFloatLiteralExprSyntax(data)
     case .tupleExpr:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -471,6 +471,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `ArrowExprSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ArrowExprSyntax) {}
+  /// Visiting `InfixOperatorExprSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `InfixOperatorExprSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: InfixOperatorExprSyntax) {}
   /// Visiting `FloatLiteralExprSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -3162,6 +3172,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplInfixOperatorExprSyntax(_ data: SyntaxData) {
+      let node = InfixOperatorExprSyntax(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 visitImplFloatLiteralExprSyntax(_ data: SyntaxData) {
       let node = FloatLiteralExprSyntax(data)
@@ -5622,6 +5643,8 @@ open class SyntaxVisitor {
       visitImplBinaryOperatorExprSyntax(data)
     case .arrowExpr:
       visitImplArrowExprSyntax(data)
+    case .infixOperatorExpr:
+      visitImplInfixOperatorExprSyntax(data)
     case .floatLiteralExpr:
       visitImplFloatLiteralExprSyntax(data)
     case .tupleExpr: