Fix a crash when string interpolation creates a MissingStmtSyntax

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -203,12 +203,20 @@ public struct RawMissingSyntax: RawSyntaxNodeProtocol {
   }
 
   public init(
+    _ unexpected: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
-    let raw = RawSyntax.makeEmptyLayout(kind: .missing, arena: arena)
+    let raw = RawSyntax.makeLayout(
+      kind: .missing, uninitializedCount: 1, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpected?.raw
+    }
     self.init(raw: raw)
   }
 
+  public var unexpected: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 }
 
 @_spi(RawSyntax)
@@ -295,12 +303,20 @@ public struct RawMissingExprSyntax: RawExprSyntaxNodeProtocol {
   }
 
   public init(
+    _ unexpected: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
-    let raw = RawSyntax.makeEmptyLayout(kind: .missingExpr, arena: arena)
+    let raw = RawSyntax.makeLayout(
+      kind: .missingExpr, uninitializedCount: 1, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpected?.raw
+    }
     self.init(raw: raw)
   }
 
+  public var unexpected: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 }
 
 @_spi(RawSyntax)
@@ -327,12 +343,20 @@ public struct RawMissingStmtSyntax: RawStmtSyntaxNodeProtocol {
   }
 
   public init(
+    _ unexpected: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
-    let raw = RawSyntax.makeEmptyLayout(kind: .missingStmt, arena: arena)
+    let raw = RawSyntax.makeLayout(
+      kind: .missingStmt, uninitializedCount: 1, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpected?.raw
+    }
     self.init(raw: raw)
   }
 
+  public var unexpected: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 }
 
 @_spi(RawSyntax)
@@ -359,12 +383,20 @@ public struct RawMissingTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
 
   public init(
+    _ unexpected: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
-    let raw = RawSyntax.makeEmptyLayout(kind: .missingType, arena: arena)
+    let raw = RawSyntax.makeLayout(
+      kind: .missingType, uninitializedCount: 1, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpected?.raw
+    }
     self.init(raw: raw)
   }
 
+  public var unexpected: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 }
 
 @_spi(RawSyntax)
@@ -391,12 +423,20 @@ public struct RawMissingPatternSyntax: RawPatternSyntaxNodeProtocol {
   }
 
   public init(
+    _ unexpected: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
-    let raw = RawSyntax.makeEmptyLayout(kind: .missingPattern, arena: arena)
+    let raw = RawSyntax.makeLayout(
+      kind: .missingPattern, uninitializedCount: 1, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpected?.raw
+    }
     self.init(raw: raw)
   }
 
+  public var unexpected: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 }
 
 @_spi(RawSyntax)

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -88,7 +88,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
   case .token:
     assertionFailure("validateLayout for .token kind is not supported")
   case .missing:
-    assert(layout.count == 0)
+    assert(layout.count == 1)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     break
   case .missingDecl:
     assert(layout.count == 5)
@@ -99,16 +100,20 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     break
   case .missingExpr:
-    assert(layout.count == 0)
+    assert(layout.count == 1)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     break
   case .missingStmt:
-    assert(layout.count == 0)
+    assert(layout.count == 1)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     break
   case .missingType:
-    assert(layout.count == 0)
+    assert(layout.count == 1)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     break
   case .missingPattern:
-    assert(layout.count == 0)
+    assert(layout.count == 1)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     break
   case .codeBlockItem:
     assert(layout.count == 5)

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -41,12 +41,25 @@ public enum SyntaxFactory {
 
 
 
+  @available(*, deprecated, message: "Use initializer on MissingSyntax")
+  public static func makeMissing(_ unexpected: UnexpectedNodesSyntax? = nil) -> MissingSyntax {
+    let layout: [RawSyntax?] = [
+      unexpected?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.missing,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return MissingSyntax(data)
+    }
+  }
 
   @available(*, deprecated, message: "Use initializer on MissingSyntax")
   public static func makeBlankMissing(presence: SourcePresence = .missing) -> MissingSyntax {
     return withExtendedLifetime(SyntaxArena()) { arena in
       let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .missing,
         from: [
+        nil,
       ], arena: arena))
       return MissingSyntax(data)
     }
@@ -82,42 +95,94 @@ public enum SyntaxFactory {
       return MissingDeclSyntax(data)
     }
   }
+  @available(*, deprecated, message: "Use initializer on MissingExprSyntax")
+  public static func makeMissingExpr(_ unexpected: UnexpectedNodesSyntax? = nil) -> MissingExprSyntax {
+    let layout: [RawSyntax?] = [
+      unexpected?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.missingExpr,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return MissingExprSyntax(data)
+    }
+  }
 
   @available(*, deprecated, message: "Use initializer on MissingExprSyntax")
   public static func makeBlankMissingExpr(presence: SourcePresence = .missing) -> MissingExprSyntax {
     return withExtendedLifetime(SyntaxArena()) { arena in
       let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .missingExpr,
         from: [
+        nil,
       ], arena: arena))
       return MissingExprSyntax(data)
     }
   }
+  @available(*, deprecated, message: "Use initializer on MissingStmtSyntax")
+  public static func makeMissingStmt(_ unexpected: UnexpectedNodesSyntax? = nil) -> MissingStmtSyntax {
+    let layout: [RawSyntax?] = [
+      unexpected?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.missingStmt,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return MissingStmtSyntax(data)
+    }
+  }
 
   @available(*, deprecated, message: "Use initializer on MissingStmtSyntax")
   public static func makeBlankMissingStmt(presence: SourcePresence = .missing) -> MissingStmtSyntax {
     return withExtendedLifetime(SyntaxArena()) { arena in
       let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .missingStmt,
         from: [
+        nil,
       ], arena: arena))
       return MissingStmtSyntax(data)
     }
   }
+  @available(*, deprecated, message: "Use initializer on MissingTypeSyntax")
+  public static func makeMissingType(_ unexpected: UnexpectedNodesSyntax? = nil) -> MissingTypeSyntax {
+    let layout: [RawSyntax?] = [
+      unexpected?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.missingType,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return MissingTypeSyntax(data)
+    }
+  }
 
   @available(*, deprecated, message: "Use initializer on MissingTypeSyntax")
   public static func makeBlankMissingType(presence: SourcePresence = .missing) -> MissingTypeSyntax {
     return withExtendedLifetime(SyntaxArena()) { arena in
       let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .missingType,
         from: [
+        nil,
       ], arena: arena))
       return MissingTypeSyntax(data)
     }
   }
+  @available(*, deprecated, message: "Use initializer on MissingPatternSyntax")
+  public static func makeMissingPattern(_ unexpected: UnexpectedNodesSyntax? = nil) -> MissingPatternSyntax {
+    let layout: [RawSyntax?] = [
+      unexpected?.raw,
+    ]
+    return withExtendedLifetime(SyntaxArena()) { arena in
+      let raw = RawSyntax.makeLayout(kind: SyntaxKind.missingPattern,
+        from: layout, arena: arena)
+      let data = SyntaxData.forRoot(raw)
+      return MissingPatternSyntax(data)
+    }
+  }
 
   @available(*, deprecated, message: "Use initializer on MissingPatternSyntax")
   public static func makeBlankMissingPattern(presence: SourcePresence = .missing) -> MissingPatternSyntax {
     return withExtendedLifetime(SyntaxArena()) { arena in
       let data = SyntaxData.forRoot(RawSyntax.makeLayout(kind: .missingPattern,
         from: [
+        nil,
       ], arena: arena))
       return MissingPatternSyntax(data)
     }

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift

@@ -31,23 +31,44 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public init() {
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpected: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed 
     // before they can be added as children of the new arena.
-    let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ())) { (arena, _) in
-      let raw = RawSyntax.makeEmptyLayout(kind: SyntaxKind.missingExpr, arena: arena)
+    let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpected?.raw,
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.missingExpr, from: layout, arena: arena,
+        leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia)
       return SyntaxData.forRoot(raw)
     }
     self.init(data)
   }
 
+  public var unexpected: UnexpectedNodesSyntax? {
+    get {
+      return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
+    }
+    set(value) {
+      self = MissingExprSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena()))
+    }
+  }
+
   public static var structure: SyntaxNodeStructure {
     return .layout([
+      \Self.unexpected,
     ])
   }
 
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
+    case 0:
+      return nil
     default:
       fatalError("Invalid index")
     }
@@ -57,6 +78,7 @@ public struct MissingExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
 extension MissingExprSyntax: CustomReflectable {
   public var customMirror: Mirror {
     return Mirror(self, children: [
+      "unexpected": unexpected.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
     ])
   }
 }

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -31,23 +31,44 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public init() {
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpected: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed 
     // before they can be added as children of the new arena.
-    let data: SyntaxData = withExtendedLifetime((SyntaxArena(), ())) { (arena, _) in
-      let raw = RawSyntax.makeEmptyLayout(kind: SyntaxKind.missing, arena: arena)
+    let data: SyntaxData = withExtendedLifetime((SyntaxArena(), (unexpected))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpected?.raw,
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.missing, from: layout, arena: arena,
+        leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia)
       return SyntaxData.forRoot(raw)
     }
     self.init(data)
   }
 
+  public var unexpected: UnexpectedNodesSyntax? {
+    get {
+      return data.child(at: 0, parent: Syntax(self)).map(UnexpectedNodesSyntax.init)
+    }
+    set(value) {
+      self = MissingSyntax(data.replacingChild(at: 0, with: value?.raw, arena: SyntaxArena()))
+    }
+  }
+
   public static var structure: SyntaxNodeStructure {
     return .layout([
+      \Self.unexpected,
     ])
   }
 
   public func childNameForDiagnostics(_ index: SyntaxChildrenIndex) -> String? {
     switch index.data?.indexInParent {
+    case 0:
+      return nil
     default:
       fatalError("Invalid index")
     }
@@ -57,6 +78,7 @@ public struct MissingSyntax: SyntaxProtocol, SyntaxHashable {
 extension MissingSyntax: CustomReflectable {
   public var customMirror: Mirror {
     return Mirror(self, children: [
+      "unexpected": unexpected.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
     ])
   }
 }