[libSyntax] Allow adding garbage nodes in between any two children of a syntax node

lib/Parse/ParseExpr.cpp

@@ -1688,10 +1688,12 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
       if (SyntaxContext->isEnabled()) {
         ParsedPatternSyntax PatternNode =
             ParsedSyntaxRecorder::makeIdentifierPattern(
-                                    SyntaxContext->popToken(), *SyntaxContext);
+                /*GarbageNodes=*/None,
+                /*Identifier=*/SyntaxContext->popToken(), *SyntaxContext);
         ParsedExprSyntax ExprNode =
-            ParsedSyntaxRecorder::makeUnresolvedPatternExpr(std::move(PatternNode),
-                                                             *SyntaxContext);
+            ParsedSyntaxRecorder::makeUnresolvedPatternExpr(
+                /*GarbageNodes=*/None,
+                /*Pattern=*/std::move(PatternNode), *SyntaxContext);
         SyntaxContext->addSyntax(std::move(ExprNode));
       }
       return makeParserResult(new (Context) UnresolvedPatternExpr(pattern));

lib/Parse/ParseIfConfig.cpp

@@ -817,8 +817,20 @@ ParserResult<IfConfigDecl> Parser::parseIfConfig(
     // clause unless we're doing a parse-only pass.
     if (isElse) {
       isActive = !foundActive && shouldEvaluate;
-      if (SyntaxContext->isEnabled())
+      if (SyntaxContext->isEnabled()) {
+        // Because we use the same libSyntax node for #elseif and #else, we need
+        // to disambiguate whether a postfix expression is the condition of
+        // #elseif or a postfix expression of the #else body.
+        // To do this, push three empty syntax nodes onto the stack.
+        //  - First one for garbage nodes between the #else keyword and the
+        //    condition
+        //  - One for the condition itself (whcih doesn't exist)
+        //  - And finally one for the garbage nodes between the condition and
+        //    the elements
         SyntaxContext->addRawSyntax(ParsedRawSyntaxNode());
+        SyntaxContext->addRawSyntax(ParsedRawSyntaxNode());
+        SyntaxContext->addRawSyntax(ParsedRawSyntaxNode());
+      }
     } else {
       llvm::SaveAndRestore<bool> S(InPoundIfEnvironment, true);
       ParserResult<Expr> Result = parseExprSequence(diag::expected_expr,

lib/Parse/ParseType.cpp

@@ -916,7 +916,10 @@ Parser::parseTypeSimpleOrComposition(Diag<> MessageID, ParseTypeReason reason) {
   if (SyntaxContext->isEnabled()) {
     if (auto synType = SyntaxContext->popIf<ParsedTypeSyntax>()) {
       auto LastNode = ParsedSyntaxRecorder::makeCompositionTypeElement(
-          std::move(*synType), None, *SyntaxContext);
+          /*GarbageNodes=*/None,
+          /*Type=*/std::move(*synType),
+          /*GarbageNodes=*/None,
+          /*Ampersand=*/None, *SyntaxContext);
       SyntaxContext->addSyntax(std::move(LastNode));
     }
   }

lib/Parse/ParsedSyntaxRecorder.cpp.gyb

@@ -172,6 +172,23 @@ ParsedTupleTypeElementSyntax
 ParsedSyntaxRecorder::makeTupleTypeElement(ParsedTypeSyntax Type,
                                     llvm::Optional<ParsedTokenSyntax> TrailingComma,
                                     SyntaxParsingContext &SPCtx) {
-  return makeTupleTypeElement(None, None, None, None, std::move(Type), None, None,
-                              std::move(TrailingComma), SPCtx);
+  return makeTupleTypeElement(
+    /*GarbageNodes=*/None,
+    /*InOut=*/None,
+    /*GarbageNodes=*/None,
+    /*Name=*/None,
+    /*GarbageNodes=*/None,
+    /*SecondName=*/None,
+    /*GarbageNodes=*/None,
+    /*Colon=*/None,
+    /*GarbageNodes=*/None,
+    std::move(Type),
+    /*GarbageNodes=*/None,
+    /*Ellipsis=*/None,
+    /*GarbageNodes=*/None,
+    /*Initializer=*/None,
+    /*GarbageNodes=*/None,
+    std::move(TrailingComma),
+    SPCtx
+  );
 }

lib/Parse/SyntaxParsingContext.cpp

@@ -322,21 +322,21 @@ void SyntaxParsingContext::collectNodesInPlace(SyntaxKind CollectionKind,
 static ParsedRawSyntaxNode finalizeSourceFile(RootContextData &RootData,
                                            MutableArrayRef<ParsedRawSyntaxNode> Parts) {
   ParsedRawSyntaxRecorder &Recorder = RootData.Recorder;
-  ParsedRawSyntaxNode Layout[2];
+  ParsedRawSyntaxNode Layout[4];
 
   assert(!Parts.empty() && Parts.back().isToken(tok::eof));
-  Layout[1] = std::move(Parts.back());
+  Layout[3] = std::move(Parts.back());
   Parts = Parts.drop_back();
 
 
   assert(llvm::all_of(Parts, [](const ParsedRawSyntaxNode& node) {
     return node.getKind() == SyntaxKind::CodeBlockItem;
   }) && "all top level element must be 'CodeBlockItem'");
 
-  Layout[0] = Recorder.recordRawSyntax(SyntaxKind::CodeBlockItemList, Parts);
+  Layout[1] = Recorder.recordRawSyntax(SyntaxKind::CodeBlockItemList, Parts);
 
   return Recorder.recordRawSyntax(SyntaxKind::SourceFile,
-                                  llvm::makeMutableArrayRef(Layout, 2));
+                                  llvm::makeMutableArrayRef(Layout, 4));
 }
 
 OpaqueSyntaxNode SyntaxParsingContext::finalizeRoot() {

lib/Syntax/SyntaxFactory.cpp.gyb

@@ -65,8 +65,8 @@ SyntaxFactory::countChildren(SyntaxKind Kind){
 % for node in SYNTAX_NODES:
 %   if not node.is_syntax_collection():
   case SyntaxKind::${node.syntax_kind}:
-%     child_count = len(node.children)
-%     non_optional_child_count = sum(0 if child.is_optional else 1 for child in node.children)
+%     child_count = len(node.non_garbage_children)
+%     non_optional_child_count = sum(0 if child.is_optional else 1 for child in node.non_garbage_children)
     return {${non_optional_child_count}, ${child_count}};
 %   end
 % end
@@ -243,39 +243,95 @@ SyntaxFactory::makeBlank${node.syntax_kind}() {
 % end
 
 TupleTypeSyntax SyntaxFactory::makeVoidTupleType() {
-  return makeTupleType(makeLeftParenToken({}, {}),
-                       makeBlankTupleTypeElementList(),
-                       makeRightParenToken({}, {}));
+  return makeTupleType(
+    /*GarbageNodes=*/None,
+    /*LeftParen=*/makeLeftParenToken({}, {}),
+    /*GarbageNodes=*/None,
+    /*Elements=*/makeBlankTupleTypeElementList(),
+    /*GarbageNodes=*/None,
+    /*RightParen=*/makeRightParenToken({}, {})
+  );
 }
 
 TupleTypeElementSyntax
 SyntaxFactory::makeTupleTypeElement(llvm::Optional<TokenSyntax> Label,
                                     llvm::Optional<TokenSyntax> Colon,
                                     TypeSyntax Type,
                                     llvm::Optional<TokenSyntax> TrailingComma) {
-  return makeTupleTypeElement(None, Label, None, Colon, Type, None, None,
-                              TrailingComma);
+  return makeTupleTypeElement(
+    /*GarbageNodes=*/None,
+    /*InOut=*/None,
+    /*GarbageNodes=*/None,
+    /*Name=*/Label,
+    /*GarbageNodes=*/None,
+    /*SecondName=*/None,
+    /*GarbageNodes=*/None,
+    /*Colon=*/Colon,
+    /*GarbageNodes=*/None,
+    /*Type=*/Type,
+    /*GarbageNodes=*/None,
+    /*Ellipsis=*/None,
+    /*GarbageNodes=*/None,
+    /*Intitializer=*/None,
+    /*GarbageNodes=*/None,
+    /*TrailingComma=*/TrailingComma
+  );
 }
 
 TupleTypeElementSyntax
 SyntaxFactory::makeTupleTypeElement(TypeSyntax Type,
                                     llvm::Optional<TokenSyntax> TrailingComma) {
-  return makeTupleTypeElement(None, None, None, None, Type, None, None,
-                              TrailingComma);
+  return makeTupleTypeElement(
+    /*GarbageNodes=*/None,
+    /*InOut=*/None,
+    /*GarbageNodes=*/None,
+    /*Name=*/None,
+    /*GarbageNodes=*/None,
+    /*SecondName=*/None,
+    /*GarbageNodes=*/None,
+    /*Colon=*/None,
+    /*GarbageNodes=*/None,
+    /*Type=*/Type,
+    /*GarbageNodes=*/None,
+    /*Ellipsis=*/None,
+    /*GarbageNodes=*/None,
+    /*Initializer=*/None,
+    /*GarbageNodes=*/None,
+    /*TrailingComma=*/TrailingComma
+  );
 }
 
 GenericParameterSyntax
 SyntaxFactory::makeGenericParameter(TokenSyntax Name,
                                     llvm::Optional<TokenSyntax> TrailingComma) {
-  return makeGenericParameter(None, Name, None, None, TrailingComma);
+  return makeGenericParameter(
+    /*GarbageNodes=*/None,
+    /*Attributes=*/None,
+    /*GarbageNodes=*/None,
+    /*Name=*/Name,
+    /*GarbageNodes=*/None,
+    /*Colon=*/None,
+    /*GarbageNodes=*/None,
+    /*InheritedType=*/None,
+    /*GarbageNodes=*/None,
+    /*TrailingComma=*/TrailingComma
+  );
 }
 
 TypeSyntax SyntaxFactory::makeTypeIdentifier(StringRef TypeName,
                                              StringRef LeadingTrivia,
                                              StringRef TrailingTrivia) {
-  auto identifier =
-      makeIdentifier(TypeName, LeadingTrivia, TrailingTrivia);
-  return makeSimpleTypeIdentifier(identifier, None);
+  auto identifier = makeIdentifier(
+    TypeName,
+    LeadingTrivia,
+    TrailingTrivia
+  );
+  return makeSimpleTypeIdentifier(
+    /*GarbageNodes=*/None,
+    /*Name=*/identifier,
+    /*GarbageNodes=*/None,
+    /*GenerigArgumentClause=*/None
+  );
 }
 
 TypeSyntax SyntaxFactory::makeAnyTypeIdentifier(StringRef LeadingTrivia,

test/Syntax/Inputs/serialize_class_decl.json

@@ -1,22 +1,27 @@
 {
   "kind": "SourceFile",
   "layout": [
+    null,
     {
       "kind": "CodeBlockItemList",
       "layout": [
         {
           "kind": "CodeBlockItem",
           "layout": [
+            null,
             {
               "kind": "ClassDecl",
               "layout": [
+                null,
+                null,
                 null,
                 {
                   "kind": "ModifierList",
                   "layout": [
                     {
                       "kind": "DeclModifier",
                       "layout": [
+                        null,
                         {
                           "tokenKind": {
                             "kind": "contextual_keyword",
@@ -26,13 +31,15 @@
                           "trailingTrivia": " ",
                           "presence": "Present"
                         },
+                        null,
                         null
                       ],
                       "presence": "Present"
                     }
                   ],
                   "presence": "Present"
                 },
+                null,
                 {
                   "tokenKind": {
                     "kind": "kw_class"
@@ -41,6 +48,7 @@
                   "trailingTrivia": " ",
                   "presence": "Present"
                 },
+                null,
                 {
                   "tokenKind": {
                     "kind": "identifier",
@@ -53,9 +61,14 @@
                 null,
                 null,
                 null,
+                null,
+                null,
+                null,
+                null,
                 {
                   "kind": "MemberDeclBlock",
                   "layout": [
+                    null,
                     {
                       "tokenKind": {
                         "kind": "l_brace"
@@ -64,11 +77,13 @@
                       "trailingTrivia": "",
                       "presence": "Present"
                     },
+                    null,
                     {
                       "kind": "MemberDeclList",
                       "layout": [],
                       "presence": "Present"
                     },
+                    null,
                     {
                       "tokenKind": {
                         "kind": "r_brace"
@@ -84,13 +99,16 @@
               "presence": "Present"
             },
             null,
+            null,
+            null,
             null
           ],
           "presence": "Present"
         }
       ],
       "presence": "Present"
     },
+    null,
     {
       "tokenKind": {
         "kind": "eof",