Regenerate sources

DougGregor · DougGregor · commit f976e0de8510 · 2022-12-10T15:35:54.000-08:00
diff --git a/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift b/CodeGeneration/Sources/SyntaxSupport/gyb_generated/ExprNodes.swift
@@ -1226,35 +1226,6 @@ public let EXPR_NODES: [Node] = [
                ])
        ]),
 
-  Node(name: "ObjectLiteralExpr",
-       nameForDiagnostics: "object literal",
-       kind: "Expr",
-       traits: [
-         "Parenthesized"
-       ],
-       children: [
-         Child(name: "Identifier",
-               kind: "Token",
-               tokenChoices: [
-                 "PoundColorLiteral",
-                 "PoundFileLiteral",
-                 "PoundImageLiteral"
-               ]),
-         Child(name: "LeftParen",
-               kind: "LeftParenToken",
-               tokenChoices: [
-                 "LeftParen"
-               ]),
-         Child(name: "Arguments",
-               kind: "TupleExprElementList",
-               collectionElementName: "Argument"),
-         Child(name: "RightParen",
-               kind: "RightParenToken",
-               tokenChoices: [
-                 "RightParen"
-               ])
-       ]),
-
   Node(name: "YieldExprList",
        nameForDiagnostics: "yield list",
        kind: "SyntaxCollection",
diff --git a/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/gyb_generated/SwiftSyntax.md
@@ -157,7 +157,6 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/MacroExpansionExprSyntax>
 - <doc:SwiftSyntax/PostfixIfConfigExprSyntax>
 - <doc:SwiftSyntax/EditorPlaceholderExprSyntax>
-- <doc:SwiftSyntax/ObjectLiteralExprSyntax>
 
 ### Types
 
diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift
@@ -65,7 +65,7 @@ public struct RawExprSyntax: RawExprSyntaxNodeProtocol {
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
     switch raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr: return true
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr: return true
     default: return false
     }
   }
@@ -5593,86 +5593,6 @@ public struct RawEditorPlaceholderExprSyntax: RawExprSyntaxNodeProtocol {
   }
 }
 
-@_spi(RawSyntax)
-public struct RawObjectLiteralExprSyntax: RawExprSyntaxNodeProtocol {
-
-  @_spi(RawSyntax)
-  public var layoutView: RawSyntaxLayoutView {
-    return raw.layoutView!
-  }
-
-  public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .objectLiteralExpr
-  }
-
-  public var raw: RawSyntax
-  init(raw: RawSyntax) {
-    assert(Self.isKindOf(raw))
-    self.raw = raw
-  }
-
-  public init?<Node: RawSyntaxNodeProtocol>(_ other: Node) {
-    guard Self.isKindOf(other.raw) else { return nil }
-    self.init(raw: other.raw)
-  }
-
-  public init(
-    _ unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? = nil,
-    identifier: RawTokenSyntax,
-    _ unexpectedBetweenIdentifierAndLeftParen: RawUnexpectedNodesSyntax? = nil,
-    leftParen: RawTokenSyntax,
-    _ unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? = nil,
-    arguments: RawTupleExprElementListSyntax,
-    _ unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? = nil,
-    rightParen: RawTokenSyntax,
-    _ unexpectedAfterRightParen: RawUnexpectedNodesSyntax? = nil,
-    arena: __shared SyntaxArena
-  ) {
-    let raw = RawSyntax.makeLayout(
-      kind: .objectLiteralExpr, uninitializedCount: 9, arena: arena) { layout in
-      layout.initialize(repeating: nil)
-      layout[0] = unexpectedBeforeIdentifier?.raw
-      layout[1] = identifier.raw
-      layout[2] = unexpectedBetweenIdentifierAndLeftParen?.raw
-      layout[3] = leftParen.raw
-      layout[4] = unexpectedBetweenLeftParenAndArguments?.raw
-      layout[5] = arguments.raw
-      layout[6] = unexpectedBetweenArgumentsAndRightParen?.raw
-      layout[7] = rightParen.raw
-      layout[8] = unexpectedAfterRightParen?.raw
-    }
-    self.init(raw: raw)
-  }
-
-  public var unexpectedBeforeIdentifier: RawUnexpectedNodesSyntax? {
-    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var identifier: RawTokenSyntax {
-    layoutView.children[1].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenIdentifierAndLeftParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var leftParen: RawTokenSyntax {
-    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenLeftParenAndArguments: RawUnexpectedNodesSyntax? {
-    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var arguments: RawTupleExprElementListSyntax {
-    layoutView.children[5].map(RawTupleExprElementListSyntax.init(raw:))!
-  }
-  public var unexpectedBetweenArgumentsAndRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-  public var rightParen: RawTokenSyntax {
-    layoutView.children[7].map(RawTokenSyntax.init(raw:))!
-  }
-  public var unexpectedAfterRightParen: RawUnexpectedNodesSyntax? {
-    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
-  }
-}
-
 @_spi(RawSyntax)
 public struct RawYieldExprListSyntax: RawSyntaxNodeProtocol {
 
diff --git a/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift b/Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift
@@ -813,18 +813,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     break
-  case .objectLiteralExpr:
-    assert(layout.count == 9)
-    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self))
-    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax.self))
-    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 5, verify(layout[5], as: RawTupleExprElementListSyntax.self))
-    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 7, verify(layout[7], as: RawTokenSyntax.self))
-    assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
-    break
   case .yieldExprList:
     for (index, element) in layout.enumerated() {
       assertNoError(kind, index, verify(element, as: RawYieldExprListElementSyntax.self))
diff --git a/Sources/SwiftSyntax/gyb_generated/Misc.swift b/Sources/SwiftSyntax/gyb_generated/Misc.swift
@@ -108,7 +108,6 @@ extension Syntax {
       .node(MacroExpansionExprSyntax.self),
       .node(PostfixIfConfigExprSyntax.self),
       .node(EditorPlaceholderExprSyntax.self),
-      .node(ObjectLiteralExprSyntax.self),
       .node(YieldExprListSyntax.self),
       .node(YieldExprListElementSyntax.self),
       .node(TypeInitializerClauseSyntax.self),
@@ -390,7 +389,6 @@ extension SyntaxKind {
     case .macroExpansionExpr: return MacroExpansionExprSyntax.self
     case .postfixIfConfigExpr: return PostfixIfConfigExprSyntax.self
     case .editorPlaceholderExpr: return EditorPlaceholderExprSyntax.self
-    case .objectLiteralExpr: return ObjectLiteralExprSyntax.self
     case .yieldExprList: return YieldExprListSyntax.self
     case .yieldExprListElement: return YieldExprListElementSyntax.self
     case .typeInitializerClause: return TypeInitializerClauseSyntax.self
@@ -763,8 +761,6 @@ extension SyntaxKind {
       return nil
     case .editorPlaceholderExpr:
       return "editor placeholder"
-    case .objectLiteralExpr:
-      return "object literal"
     case .yieldExprList:
       return "yield list"
     case .yieldExprListElement:
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift
@@ -698,13 +698,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: EditorPlaceholderExprSyntax) {
     visitAnyPost(node._syntaxNode)
   }
-  override open func visit(_ node: ObjectLiteralExprSyntax) -> SyntaxVisitorContinueKind {
-    return visitAny(node._syntaxNode)
-  }
-
-  override open func visitPost(_ node: ObjectLiteralExprSyntax) {
-    visitAnyPost(node._syntaxNode)
-  }
   override open func visit(_ node: YieldExprListSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift
@@ -216,7 +216,7 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 
   public init?<S: SyntaxProtocol>(_ node: S) {
     switch node.raw.kind {
-    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr:
       self._syntaxNode = node._syntaxNode
     default:
       return nil
@@ -230,7 +230,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, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr, .objectLiteralExpr:
+    case .unknownExpr, .missingExpr, .inOutExpr, .poundColumnExpr, .tryExpr, .awaitExpr, .moveExpr, .identifierExpr, .superRefExpr, .nilLiteralExpr, .discardAssignmentExpr, .assignmentExpr, .sequenceExpr, .poundLineExpr, .poundFileExpr, .poundFileIDExpr, .poundFilePathExpr, .poundFunctionExpr, .poundDsohandleExpr, .symbolicReferenceExpr, .prefixOperatorExpr, .binaryOperatorExpr, .arrowExpr, .infixOperatorExpr, .floatLiteralExpr, .tupleExpr, .arrayExpr, .dictionaryExpr, .integerLiteralExpr, .booleanLiteralExpr, .unresolvedTernaryExpr, .ternaryExpr, .memberAccessExpr, .unresolvedIsExpr, .isExpr, .unresolvedAsExpr, .asExpr, .typeExpr, .closureExpr, .unresolvedPatternExpr, .functionCallExpr, .subscriptExpr, .optionalChainingExpr, .forcedValueExpr, .postfixUnaryExpr, .specializeExpr, .stringLiteralExpr, .regexLiteralExpr, .keyPathExpr, .macroExpansionExpr, .postfixIfConfigExpr, .editorPlaceholderExpr:
       break
     default:
       fatalError("Unable to create ExprSyntax from \(data.raw.kind)")
@@ -320,7 +320,6 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
       .node(MacroExpansionExprSyntax.self),
       .node(PostfixIfConfigExprSyntax.self),
       .node(EditorPlaceholderExprSyntax.self),
-      .node(ObjectLiteralExprSyntax.self),
     ])
   }
 
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift
@@ -108,7 +108,6 @@ public enum SyntaxEnum {
   case macroExpansionExpr(MacroExpansionExprSyntax)
   case postfixIfConfigExpr(PostfixIfConfigExprSyntax)
   case editorPlaceholderExpr(EditorPlaceholderExprSyntax)
-  case objectLiteralExpr(ObjectLiteralExprSyntax)
   case yieldExprList(YieldExprListSyntax)
   case yieldExprListElement(YieldExprListElementSyntax)
   case typeInitializerClause(TypeInitializerClauseSyntax)
@@ -482,8 +481,6 @@ public extension Syntax {
       return .postfixIfConfigExpr(PostfixIfConfigExprSyntax(self)!)
     case .editorPlaceholderExpr:
       return .editorPlaceholderExpr(EditorPlaceholderExprSyntax(self)!)
-    case .objectLiteralExpr:
-      return .objectLiteralExpr(ObjectLiteralExprSyntax(self)!)
     case .yieldExprList:
       return .yieldExprList(YieldExprListSyntax(self)!)
     case .yieldExprListElement:
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
@@ -2661,45 +2661,6 @@ public enum SyntaxFactory {
       return EditorPlaceholderExprSyntax(data)
     }
   }
-  @available(*, deprecated, message: "Use initializer on ObjectLiteralExprSyntax")
-  public static func makeObjectLiteralExpr(_ unexpectedBeforeIdentifier: UnexpectedNodesSyntax? = nil, identifier: TokenSyntax, _ unexpectedBetweenIdentifierAndLeftParen: UnexpectedNodesSyntax? = nil, leftParen: TokenSyntax, _ unexpectedBetweenLeftParenAndArguments: UnexpectedNodesSyntax? = nil, arguments: TupleExprElementListSyntax, _ unexpectedBetweenArgumentsAndRightParen: UnexpectedNodesSyntax? = nil, rightParen: TokenSyntax, _ unexpectedAfterRightParen: UnexpectedNodesSyntax? = nil) -> ObjectLiteralExprSyntax {
-    let layout: [RawSyntax?] = [
-      unexpectedBeforeIdentifier?.raw,
-      identifier.raw,
-      unexpectedBetweenIdentifierAndLeftParen?.raw,
-      leftParen.raw,
-      unexpectedBetweenLeftParenAndArguments?.raw,
-      arguments.raw,
-      unexpectedBetweenArgumentsAndRightParen?.raw,
-      rightParen.raw,
-      unexpectedAfterRightParen?.raw,
-    ]
-    return withExtendedLifetime(SyntaxArena()) { arena in
-      let raw = RawSyntax.makeLayout(kind: SyntaxKind.objectLiteralExpr,
-        from: layout, arena: arena)
-      let data = SyntaxData.forRoot(raw)
-      return ObjectLiteralExprSyntax(data)
-    }
-  }
-
-  @available(*, deprecated, message: "Use initializer on ObjectLiteralExprSyntax")
-  public static func makeBlankObjectLiteralExpr(presence: SourcePresence = .present) -> ObjectLiteralExprSyntax {
-    return withExtendedLifetime(SyntaxArena()) { arena in
-      let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .objectLiteralExpr,
-        from: [
-        nil,
-        RawSyntax.makeMissingToken(kind: TokenKind.poundColorLiteralKeyword, arena: arena),
-        nil,
-        RawSyntax.makeMissingToken(kind: TokenKind.leftParen, arena: arena),
-        nil,
-        RawSyntax.makeEmptyLayout(kind: SyntaxKind.tupleExprElementList, arena: arena),
-        nil,
-        RawSyntax.makeMissingToken(kind: TokenKind.rightParen, arena: arena),
-        nil,
-      ], arena: arena))
-      return ObjectLiteralExprSyntax(data)
-    }
-  }
   @available(*, deprecated, message: "Use initializer on YieldExprListSyntax")
   public static func makeYieldExprList(
     _ elements: [YieldExprListElementSyntax]) -> YieldExprListSyntax {
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift
@@ -108,7 +108,6 @@ public enum SyntaxKind {
   case macroExpansionExpr
   case postfixIfConfigExpr
   case editorPlaceholderExpr
-  case objectLiteralExpr
   case yieldExprList
   case yieldExprListElement
   case typeInitializerClause
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
@@ -660,13 +660,6 @@ open class SyntaxRewriter {
     return ExprSyntax(visitChildren(node))
   }
 
-  /// Visit a `ObjectLiteralExprSyntax`.
-  ///   - Parameter node: the node that is being visited
-  ///   - Returns: the rewritten node
-  open func visit(_ node: ObjectLiteralExprSyntax) -> ExprSyntax {
-    return ExprSyntax(visitChildren(node))
-  }
-
   /// Visit a `YieldExprListSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2975,16 +2968,6 @@ open class SyntaxRewriter {
       return Syntax(visit(node))
   }
 
-  /// Implementation detail of visit(_:). Do not call directly.
-  private func visitImplObjectLiteralExprSyntax(_ data: SyntaxData) -> Syntax {
-      let node = ObjectLiteralExprSyntax(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 visitImplYieldExprListSyntax(_ data: SyntaxData) -> Syntax {
       let node = YieldExprListSyntax(data)
@@ -5029,8 +5012,6 @@ open class SyntaxRewriter {
       return visitImplPostfixIfConfigExprSyntax
     case .editorPlaceholderExpr:
       return visitImplEditorPlaceholderExprSyntax
-    case .objectLiteralExpr:
-      return visitImplObjectLiteralExprSyntax
     case .yieldExprList:
       return visitImplYieldExprListSyntax
     case .yieldExprListElement:
@@ -5590,8 +5571,6 @@ open class SyntaxRewriter {
       return visitImplPostfixIfConfigExprSyntax(data)
     case .editorPlaceholderExpr:
       return visitImplEditorPlaceholderExprSyntax(data)
-    case .objectLiteralExpr:
-      return visitImplObjectLiteralExprSyntax(data)
     case .yieldExprList:
       return visitImplYieldExprListSyntax(data)
     case .yieldExprListElement:
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTraits.swift
@@ -192,7 +192,6 @@ extension ClosureCaptureItemSyntax: WithTrailingCommaSyntax {}
 extension ClosureParamSyntax: WithTrailingCommaSyntax {}
 extension ClosureExprSyntax: BracedSyntax, WithStatementsSyntax {}
 extension ExpressionSegmentSyntax: ParenthesizedSyntax {}
-extension ObjectLiteralExprSyntax: ParenthesizedSyntax {}
 extension TypealiasDeclSyntax: IdentifiedDeclSyntax {}
 extension AssociatedtypeDeclSyntax: IdentifiedDeclSyntax {}
 extension ParameterClauseSyntax: ParenthesizedSyntax {}
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxTransform.swift
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift
diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift
diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift
diff --git a/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift b/Sources/SwiftSyntaxBuilder/generated/Typealiases.swift

Original file line number	Diff line number	Diff line change
`@@ -698,13 +698,6 @@ open class SyntaxAnyVisitor: SyntaxVisitor {`
`698`	`698`	`override open func visitPost(_ node: EditorPlaceholderExprSyntax) {`
`699`	`699`	`visitAnyPost(node._syntaxNode)`
`700`	`700`	`}`
`701`		`- override open func visit(_ node: ObjectLiteralExprSyntax) -> SyntaxVisitorContinueKind {`
`702`		`- return visitAny(node._syntaxNode)`
`703`		`- }`
`704`		`-`
`705`		`- override open func visitPost(_ node: ObjectLiteralExprSyntax) {`
`706`		`- visitAnyPost(node._syntaxNode)`
`707`		`- }`
`708`	`701`	`override open func visit(_ node: YieldExprListSyntax) -> SyntaxVisitorContinueKind {`
`709`	`702`	`return visitAny(node._syntaxNode)`
`710`	`703`	`}`