libSyntax: add a test to ensure the generated syntax kinds from parser are expected.

include/swift/Syntax/RawSyntax.h

@@ -184,6 +184,11 @@ enum class SourcePresence {
   Missing,
 };
 
+/// The print option to specify when printing a raw syntax node.
+struct SyntaxPrintOptions {
+  bool PrintSyntaxKind = false;
+};
+
 /// RawSyntax - the strictly immutable, shared backing nodes for all syntax.
 ///
 /// This is implementation detail - do not expose it in public API.
@@ -298,7 +303,7 @@ struct RawSyntax : public llvm::ThreadSafeRefCountedBase<RawSyntax> {
   }
 
   /// Print this piece of syntax recursively.
-  void print(llvm::raw_ostream &OS) const;
+  void print(llvm::raw_ostream &OS, SyntaxPrintOptions Opts) const;
 
   /// Dump this piece of syntax recursively for debugging or testing.
   void dump() const;

include/swift/Syntax/Syntax.h

@@ -156,7 +156,7 @@ class Syntax {
   bool isPresent() const;
 
   /// Print the syntax node with full fidelity to the given output stream.
-  void print(llvm::raw_ostream &OS) const;
+  void print(llvm::raw_ostream &OS, SyntaxPrintOptions Opts = SyntaxPrintOptions()) const;
 
   /// Print a debug representation of the syntax node to the given output stream
   /// and indentation level.

include/swift/Syntax/SyntaxKind.h.gyb

@@ -47,6 +47,9 @@ enum class SyntaxKind {
 
 void dumpSyntaxKind(llvm::raw_ostream &os, const SyntaxKind kind);
 
+/// Whether this kind is a syntax collection.
+bool isCollectionKind(SyntaxKind Kind);
+
 } // end namespace syntax
 
 namespace json {

lib/Syntax/RawSyntax.cpp

@@ -20,13 +20,40 @@
 using llvm::dyn_cast;
 using namespace swift::syntax;
 
-void RawSyntax::print(llvm::raw_ostream &OS) const {
+namespace {
+static bool isTrivialSyntaxKind(SyntaxKind Kind) {
+  if (isCollectionKind(Kind))
+    return true;
+  switch(Kind) {
+  case SyntaxKind::SourceFile:
+  case SyntaxKind::TopLevelCodeDecl:
+  case SyntaxKind::ExpressionStmt:
+    return true;
+  default:
+    return false;
+  }
+}
+} // end of anonymous namespace
+void RawSyntax::print(llvm::raw_ostream &OS, SyntaxPrintOptions Opts) const {
+  const bool PrintKind = Opts.PrintSyntaxKind && !isToken() &&
+    !isTrivialSyntaxKind(Kind);
+  if (PrintKind) {
+    OS << "<";
+    dumpSyntaxKind(OS, Kind);
+    OS << ">";
+  }
+
   if (const auto Tok = dyn_cast<RawTokenSyntax>(this)) {
     Tok->print(OS);
   }
 
   for (const auto &LE : Layout) {
-    LE->print(OS);
+    LE->print(OS, Opts);
+  }
+  if (PrintKind) {
+    OS << "</";
+    dumpSyntaxKind(OS, Kind);
+    OS << ">";
   }
 }
 

lib/Syntax/Syntax.cpp

@@ -24,8 +24,8 @@ SyntaxKind Syntax::getKind() const {
   return getRaw()->Kind;
 }
 
-void Syntax::print(llvm::raw_ostream &OS) const {
-  getRaw()->print(OS);
+void Syntax::print(llvm::raw_ostream &OS, SyntaxPrintOptions Opts) const {
+  getRaw()->print(OS, Opts);
 }
 
 void Syntax::dump() const {

lib/Syntax/SyntaxKind.cpp.gyb

@@ -38,5 +38,18 @@ void dumpSyntaxKind(llvm::raw_ostream &os, const SyntaxKind kind) {
   }
 }
 
+bool isCollectionKind(SyntaxKind Kind) {
+  switch(Kind) {
+%   for node in SYNTAX_NODES:
+%     if node.is_syntax_collection():
+  case SyntaxKind::${node.syntax_kind}:
+%     end
+%   end
+    return true;
+  default:
+    return false;
+  }
+}
+
 } // end namespace syntax
 } // end namespace swift

test/Syntax/Outputs/round_trip_parse_gen.swift.withkinds

@@ -0,0 +1,10 @@
+<StringLiteralExpr>// RUN: %swift-syntax-test -input-source-filename %s -parse-gen > %t
+// RUN: diff %t %s
+// RUN: %swift-syntax-test -input-source-filename %s -parse-gen -print-node-kind > %t.withkinds
+// RUN: diff %t.withkinds %S/Outputs/round_trip_parse_gen.swift.withkinds
+
+"String Literal"</StringLiteralExpr><StringLiteralExpr>
+
+""</StringLiteralExpr><IntegerLiteralExpr>
+
+/*comments*/+3 // comments</IntegerLiteralExpr>

test/Syntax/round_trip_parse_gen.swift

@@ -1,5 +1,7 @@
 // RUN: %swift-syntax-test -input-source-filename %s -parse-gen > %t
 // RUN: diff %t %s
+// RUN: %swift-syntax-test -input-source-filename %s -parse-gen -print-node-kind > %t.withkinds
+// RUN: diff %t.withkinds %S/Outputs/round_trip_parse_gen.swift.withkinds
 
 "String Literal"
 

tools/swift-syntax-test/swift-syntax-test.cpp

@@ -36,6 +36,7 @@
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
+using namespace swift::syntax;
 using llvm::StringRef;
 
 enum class ActionType {
@@ -48,6 +49,7 @@ enum class ActionType {
 };
 
 namespace options {
+static llvm::cl::OptionCategory Category("swift-syntax-test Options");
 static llvm::cl::opt<ActionType>
 Action(llvm::cl::desc("Action (required):"),
        llvm::cl::init(ActionType::None),
@@ -76,6 +78,12 @@ Action(llvm::cl::desc("Action (required):"),
 static llvm::cl::opt<std::string>
 InputSourceFilename("input-source-filename",
                     llvm::cl::desc("Path to the input .swift file"));
+
+static llvm::cl::opt<bool>
+PrintNodeKind("print-node-kind",
+              llvm::cl::desc("To print syntax node kind"),
+              llvm::cl::cat(Category),
+              llvm::cl::init(false));
 } // end namespace options
 
 namespace {
@@ -273,7 +281,9 @@ int dumpParserGen(const char *MainExecutablePath,
                   const StringRef InputFileName) {
   CompilerInstance Instance;
   SourceFile *SF = getSourceFile(Instance, InputFileName, MainExecutablePath);
-  SF->getSyntaxRoot().print(llvm::outs());
+  SyntaxPrintOptions Opts;
+  Opts.PrintSyntaxKind = options::PrintNodeKind;
+  SF->getSyntaxRoot().print(llvm::outs(), Opts);
   return 0;
 }