Introduce a new syntax kind to represent missing base nodes

Sources/SwiftSyntax/Misc.swift.gyb

@@ -54,7 +54,7 @@ extension Syntax {
       return node
     case .unknown(let node):
       return node
-% for node in SYNTAX_NODES:
+% for node in NON_BASE_SYNTAX_NODES:
     case .${node.swift_syntax_kind}(let node):
       return node
 % end

Sources/SwiftSyntax/SyntaxEnum.swift.gyb

@@ -23,7 +23,7 @@
 public enum SyntaxEnum {
   case unknown(UnknownSyntax)
   case token(TokenSyntax)
-% for node in SYNTAX_NODES:
+% for node in NON_BASE_SYNTAX_NODES:
 %   if node.is_base():
   case ${node.swift_syntax_kind}(Unknown${node.name})
 %   else:
@@ -40,7 +40,7 @@ public extension Syntax {
       return .token(TokenSyntax(self)!)
     case .unknown:
       return .unknown(UnknownSyntax(self)!)
-% for node in SYNTAX_NODES:
+% for node in NON_BASE_SYNTAX_NODES:
     case .${node.swift_syntax_kind}:
 %   if node.is_base():
       return .${node.swift_syntax_kind}(Unknown${node.name}(self)!)

Sources/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -83,7 +83,8 @@ public enum SyntaxFactory {
 %   end
 
 %   if not node.is_base():
-  public static func makeBlank${node.syntax_kind}(presence: SourcePresence = .present) -> ${node.name} {
+%   default_presence = 'missing' if node.is_missing() else 'present'
+  public static func makeBlank${node.syntax_kind}(presence: SourcePresence = .${default_presence}) -> ${node.name} {
     let data = SyntaxData.forRoot(RawSyntax.create(kind: .${node.swift_syntax_kind},
       layout: [
 %     for child in node.children:

Sources/SwiftSyntax/SyntaxKind.swift.gyb

@@ -22,7 +22,7 @@
 internal enum SyntaxKind: CSyntaxKind {
   case token = 0
   case unknown = 1
-% for node in SYNTAX_NODES:
+% for node in NON_BASE_SYNTAX_NODES:
   case ${node.swift_syntax_kind} = ${SYNTAX_NODE_SERIALIZATION_CODES[node.syntax_kind]}
 % end
 

Sources/SwiftSyntax/SyntaxRewriter.swift.gyb

@@ -157,7 +157,7 @@ open class SyntaxRewriter {
       return visitImplTokenSyntax
     case .unknown:
       return visitImplUnknownSyntax
-  % for node in SYNTAX_NODES:
+  % for node in NON_BASE_SYNTAX_NODES:
     case .${node.swift_syntax_kind}:
       return visitImpl${node.name}
   % end
@@ -176,7 +176,7 @@ open class SyntaxRewriter {
       return visitImplTokenSyntax(data)
     case .unknown:
       return visitImplUnknownSyntax(data)
-  % for node in SYNTAX_NODES:
+  % for node in NON_BASE_SYNTAX_NODES:
     case .${node.swift_syntax_kind}:
       return visitImpl${node.name}(data)
   % end

Sources/SwiftSyntax/SyntaxVisitor.swift.gyb

@@ -126,7 +126,7 @@ open class SyntaxVisitor {
     // circumvents an issue where the compiler allocates stack space for every
     // case statement next to each other in debug builds, causing it to allocate
     // ~50KB per call to this function. rdar://55929175
-  % for node in SYNTAX_NODES:
+  % for node in NON_BASE_SYNTAX_NODES:
     case .${node.swift_syntax_kind}:
       visitImpl${node.name}(data)
   % end

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -49,6 +49,42 @@ extension SyntaxNode {
     return UnknownPatternSyntax(asSyntaxData)
   }
 
+  public var isMissing: Bool { return raw.kind == .missing }
+  public var asMissing: MissingSyntax? {
+    guard isMissing else { return nil }
+    return MissingSyntax(asSyntaxData)
+  }
+
+  public var isMissingDecl: Bool { return raw.kind == .missingDecl }
+  public var asMissingDecl: MissingDeclSyntax? {
+    guard isMissingDecl else { return nil }
+    return MissingDeclSyntax(asSyntaxData)
+  }
+
+  public var isMissingExpr: Bool { return raw.kind == .missingExpr }
+  public var asMissingExpr: MissingExprSyntax? {
+    guard isMissingExpr else { return nil }
+    return MissingExprSyntax(asSyntaxData)
+  }
+
+  public var isMissingStmt: Bool { return raw.kind == .missingStmt }
+  public var asMissingStmt: MissingStmtSyntax? {
+    guard isMissingStmt else { return nil }
+    return MissingStmtSyntax(asSyntaxData)
+  }
+
+  public var isMissingType: Bool { return raw.kind == .missingType }
+  public var asMissingType: MissingTypeSyntax? {
+    guard isMissingType else { return nil }
+    return MissingTypeSyntax(asSyntaxData)
+  }
+
+  public var isMissingPattern: Bool { return raw.kind == .missingPattern }
+  public var asMissingPattern: MissingPatternSyntax? {
+    guard isMissingPattern else { return nil }
+    return MissingPatternSyntax(asSyntaxData)
+  }
+
   public var isCodeBlockItem: Bool { return raw.kind == .codeBlockItem }
   public var asCodeBlockItem: CodeBlockItemSyntax? {
     guard isCodeBlockItem else { return nil }
@@ -1531,16 +1567,6 @@ extension Syntax {
       return node
     case .unknown(let node):
       return node
-    case .decl(let node):
-      return node
-    case .expr(let node):
-      return node
-    case .stmt(let node):
-      return node
-    case .type(let node):
-      return node
-    case .pattern(let node):
-      return node
     case .unknownDecl(let node):
       return node
     case .unknownExpr(let node):
@@ -1551,6 +1577,18 @@ extension Syntax {
       return node
     case .unknownPattern(let node):
       return node
+    case .missing(let node):
+      return node
+    case .missingDecl(let node):
+      return node
+    case .missingExpr(let node):
+      return node
+    case .missingStmt(let node):
+      return node
+    case .missingType(let node):
+      return node
+    case .missingPattern(let node):
+      return node
     case .codeBlockItem(let node):
       return node
     case .codeBlockItemList(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -99,6 +99,48 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: UnknownPatternSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: MissingSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: MissingDeclSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingDeclSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: MissingExprSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingExprSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: MissingStmtSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingStmtSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: MissingTypeSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingTypeSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+  override open func visit(_ node: MissingPatternSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingPatternSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: CodeBlockItemSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -56,7 +56,7 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownDecl, .typealiasDecl, .associatedtypeDecl, .ifConfigDecl, .poundErrorDecl, .poundWarningDecl, .poundSourceLocation, .classDecl, .actorDecl, .structDecl, .protocolDecl, .extensionDecl, .functionDecl, .initializerDecl, .deinitializerDecl, .subscriptDecl, .importDecl, .accessorDecl, .variableDecl, .enumCaseDecl, .enumDecl, .operatorDecl, .precedenceGroupDecl:
+    case .unknownDecl, .missingDecl, .typealiasDecl, .associatedtypeDecl, .ifConfigDecl, .poundErrorDecl, .poundWarningDecl, .poundSourceLocation, .classDecl, .actorDecl, .structDecl, .protocolDecl, .extensionDecl, .functionDecl, .initializerDecl, .deinitializerDecl, .subscriptDecl, .importDecl, .accessorDecl, .variableDecl, .enumCaseDecl, .enumDecl, .operatorDecl, .precedenceGroupDecl:
       self._syntaxNode = syntax
     default:
       return nil
@@ -70,7 +70,7 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownDecl, .typealiasDecl, .associatedtypeDecl, .ifConfigDecl, .poundErrorDecl, .poundWarningDecl, .poundSourceLocation, .classDecl, .actorDecl, .structDecl, .protocolDecl, .extensionDecl, .functionDecl, .initializerDecl, .deinitializerDecl, .subscriptDecl, .importDecl, .accessorDecl, .variableDecl, .enumCaseDecl, .enumDecl, .operatorDecl, .precedenceGroupDecl:
+    case .unknownDecl, .missingDecl, .typealiasDecl, .associatedtypeDecl, .ifConfigDecl, .poundErrorDecl, .poundWarningDecl, .poundSourceLocation, .classDecl, .actorDecl, .structDecl, .protocolDecl, .extensionDecl, .functionDecl, .initializerDecl, .deinitializerDecl, .subscriptDecl, .importDecl, .accessorDecl, .variableDecl, .enumCaseDecl, .enumDecl, .operatorDecl, .precedenceGroupDecl:
       break
     default:
       fatalError("Unable to create DeclSyntax from \(data.raw.kind)")
@@ -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, .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, .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, .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, .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)")
@@ -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, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt:
+    case .unknownStmt, .missingStmt, .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, .continueStmt, .whileStmt, .deferStmt, .expressionStmt, .repeatWhileStmt, .guardStmt, .forInStmt, .switchStmt, .doStmt, .returnStmt, .yieldStmt, .fallthroughStmt, .breakStmt, .declarationStmt, .throwStmt, .ifStmt, .poundAssertStmt:
+    case .unknownStmt, .missingStmt, .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)")
@@ -380,7 +380,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownType, .simpleTypeIdentifier, .memberTypeIdentifier, .classRestrictionType, .arrayType, .dictionaryType, .metatypeType, .optionalType, .constrainedSugarType, .implicitlyUnwrappedOptionalType, .compositionType, .tupleType, .functionType, .attributedType:
+    case .unknownType, .missingType, .simpleTypeIdentifier, .memberTypeIdentifier, .classRestrictionType, .arrayType, .dictionaryType, .metatypeType, .optionalType, .constrainedSugarType, .implicitlyUnwrappedOptionalType, .compositionType, .tupleType, .functionType, .attributedType:
       self._syntaxNode = syntax
     default:
       return nil
@@ -394,7 +394,7 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownType, .simpleTypeIdentifier, .memberTypeIdentifier, .classRestrictionType, .arrayType, .dictionaryType, .metatypeType, .optionalType, .constrainedSugarType, .implicitlyUnwrappedOptionalType, .compositionType, .tupleType, .functionType, .attributedType:
+    case .unknownType, .missingType, .simpleTypeIdentifier, .memberTypeIdentifier, .classRestrictionType, .arrayType, .dictionaryType, .metatypeType, .optionalType, .constrainedSugarType, .implicitlyUnwrappedOptionalType, .compositionType, .tupleType, .functionType, .attributedType:
       break
     default:
       fatalError("Unable to create TypeSyntax from \(data.raw.kind)")
@@ -488,7 +488,7 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   /// `nil` if the conversion is not possible.
   public init?(_ syntax: Syntax) {
     switch syntax.raw.kind {
-    case .unknownPattern, .enumCasePattern, .isTypePattern, .optionalPattern, .identifierPattern, .asTypePattern, .tuplePattern, .wildcardPattern, .expressionPattern, .valueBindingPattern:
+    case .unknownPattern, .missingPattern, .enumCasePattern, .isTypePattern, .optionalPattern, .identifierPattern, .asTypePattern, .tuplePattern, .wildcardPattern, .expressionPattern, .valueBindingPattern:
       self._syntaxNode = syntax
     default:
       return nil
@@ -502,7 +502,7 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     // Assert that the kind of the given data matches in debug builds.
 #if DEBUG
     switch data.raw.kind {
-    case .unknownPattern, .enumCasePattern, .isTypePattern, .optionalPattern, .identifierPattern, .asTypePattern, .tuplePattern, .wildcardPattern, .expressionPattern, .valueBindingPattern:
+    case .unknownPattern, .missingPattern, .enumCasePattern, .isTypePattern, .optionalPattern, .identifierPattern, .asTypePattern, .tuplePattern, .wildcardPattern, .expressionPattern, .valueBindingPattern:
       break
     default:
       fatalError("Unable to create PatternSyntax from \(data.raw.kind)")