[Syntax] Test both the default and windows target platforms in unittests

[hlopko]

Summary

This increases the coverage for things that differ between Linux and Windows, such as -fdelayed-template-parsing. This would have prevented the rollback of https://reviews.llvm.org/D76346.

While at it, update -std=c++11 to c++17 for the test.

[hlopko]

Reformat

[hlopko]

Refactored to run tests on both default and windows platforms.

Opting out Templates test for now since it doesn't work with -fdelayed-template-parsing yet.

[gribozavr2]

clang/unittests/Tooling/Syntax/TreeTest.cpp

102

Maybe upgrade that to C++17? I hope this is where the world is moving.

124

s/SkipWindows/RunWithDelayedTemplateParsing/ ?

127

Please add a comment explaining that we want to test with delayed template parsing on and off, hence we choose two representative targets where that is normal.

815

Need an equal sign in /*SkipWindows=*/.

[hlopko]

Address comments.

[hlopko]

Rebase

[thakis]

Breaks tests on Windows: http://45.33.8.238/win/10881/step_7.txt

clang/unittests/Tooling/Syntax/TreeTest.cpp

static llvm::ArrayRef<syntax::Token> tokens(syntax::Node *N) {
   auto *T = cast<syntax::Tree>(N);
   return llvm::makeArrayRef(T->firstLeaf()->token(),
                             T->lastLeaf()->token() + 1);
 }
 
 class SyntaxTreeTest : public ::testing::Test {
 protected:
   // Build a syntax tree for the code.
-  syntax::TranslationUnit *buildTree(llvm::StringRef Code) {
+  syntax::TranslationUnit *buildTree(llvm::StringRef Code, StringRef Target) {
     // FIXME: this code is almost the identical to the one in TokensTest. Share
     //        it.
     class BuildSyntaxTree : public ASTConsumer {
     public:
       BuildSyntaxTree(syntax::TranslationUnit *&Root,
                       std::unique_ptr<syntax::Arena> &Arena,
                       std::unique_ptr<syntax::TokenCollector> Tokens)
           : Root(Root), Arena(Arena), Tokens(std::move(Tokens)) {
private:
       std::unique_ptr<syntax::Arena> &Arena;
     };
 
     constexpr const char *FileName = "./input.cpp";
     FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
     if (!Diags->getClient())
       Diags->setClient(new IgnoringDiagConsumer);
     // Prepare to run a compiler.
-    std::vector<const char *> Args = {"syntax-test", "-std=c++11",
-                                      "-fno-delayed-template-parsing",
-                                      "-fsyntax-only", FileName};
+    std::vector<const char *> Args = {"-target",       Target.data(),
+                                      "-fsyntax-only", "-std=c++17",
+                                      "syntax-test",   FileName};
     Invocation = createInvocationFromCommandLine(Args, Diags, FS);
     assert(Invocation);
     Invocation->getFrontendOpts().DisableFree = false;
     Invocation->getPreprocessorOpts().addRemappedFile(
         FileName, llvm::MemoryBuffer::getMemBufferCopy(Code).release());
     CompilerInstance Compiler;
     Compiler.setInvocation(Invocation);
     Compiler.setDiagnostics(Diags.get());
     Compiler.setFileManager(FileMgr.get());
     Compiler.setSourceManager(SourceMgr.get());
 
     syntax::TranslationUnit *Root = nullptr;
     BuildSyntaxTreeAction Recorder(Root, this->Arena);
     if (!Compiler.ExecuteAction(Recorder)) {
       ADD_FAILURE() << "failed to run the frontend";
       std::abort();
     }
     return Root;
   }
 
-  void expectTreeDumpEqual(StringRef code, StringRef tree) {
-    SCOPED_TRACE(code);
-
-    auto *Root = buildTree(code);
-    std::string Expected = tree.trim().str();
-    std::string Actual =
-        std::string(llvm::StringRef(Root->dump(*Arena)).trim());
-    EXPECT_EQ(Expected, Actual) << "the resulting dump is:\n" << Actual;
+  void expectTreeDumpEqual(StringRef Code, StringRef Tree,
+                           bool RunWithDelayedTemplateParsing = true) {
+    SCOPED_TRACE(Code);
+
+    std::string Expected = Tree.trim().str();
+
+    // We want to run the test with -fdelayed-template-parsing enabled and
+    // disabled, therefore we use these representative targets that differ in
+    // the default value.
+    // We are not passing -fdelayed-template-parsing directly but we are using
+    // the `-target` to improve coverage and discover differences in behavior
+    // early.
+    for (const StringRef Target :
+         {"x86_64-unknown-unknown", "x86_64-pc-win32"}) {
+      if (!RunWithDelayedTemplateParsing && Target.equals("x86_64-pc-win32")) {
+        continue;
+      }
+      auto *Root = buildTree(Code, Target);
+      std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
+      EXPECT_EQ(Expected, Actual)
+          << "for target " << Target << " the resulting dump is:\n"
+          << Actual;
+    }
   }
 
   // Adds a file to the test VFS.
   void addFile(llvm::StringRef Path, llvm::StringRef Contents) {
     if (!FS->addFile(Path, time_t(),
                      llvm::MemoryBuffer::getMemBufferCopy(Contents))) {
       ADD_FAILURE() << "could not add a file to VFS: " << Path;
     }
`-SimpleDeclaration
     |-SimpleDeclarator
     | |-fun
     | `-ParametersAndQualifiers
     |   |-(
     |   `-)
     `-CompoundStatement
       |-{
       `-}
-)txt");
+)txt",
+      // FIXME: Make this test work on windows by generating the expected Syntax
+      // tree when -fdelayed-template-parsing is active.
+      /*RunWithDelayedTemplateParsing=*/true);
 }
 
 TEST_F(SyntaxTreeTest, NestedTemplates) {
   expectTreeDumpEqual(
       R"cpp(
 template <class T>
 struct X {
   template <class U>

 }
 
 TEST_F(SyntaxTreeTest, Mutations) {
   using Transformation = std::function<void(
       const llvm::Annotations & /*Input*/, syntax::TranslationUnit * /*Root*/)>;
   auto CheckTransformation = [this](std::string Input, std::string Expected,
                                     Transformation Transform) -> void {
     llvm::Annotations Source(Input);
-    auto *Root = buildTree(Source.code());
+    auto *Root = buildTree(Source.code(), "x86_64-unknown-unknown");
 
     Transform(Source, Root);
 
     auto Replacements = syntax::computeReplacements(*Arena, *Root);
     auto Output = tooling::applyAllReplacements(Source.code(), Replacements);
     if (!Output) {
       ADD_FAILURE() << "could not apply replacements: "
                     << llvm::toString(Output.takeError());
std::vector<std::pair<std::string /*Input*/, std::string /*Expected*/>>
           {"void test() { if (true) [[{}]] else {} }",
            "void test() { if (true) ; else {} }"},
           {"void test() { [[;]] }", "void test() {  }"}};
   for (const auto &C : Cases)
     CheckTransformation(C.first, C.second, RemoveStatement);
 }
 
 TEST_F(SyntaxTreeTest, SynthesizedNodes) {
-  buildTree("");
+  buildTree("", "x86_64-unknown-unknown");
 
   auto *C = syntax::createPunctuation(*Arena, tok::comma);
   ASSERT_NE(C, nullptr);
   EXPECT_EQ(C->token()->kind(), tok::comma);
   EXPECT_TRUE(C->canModify());
   EXPECT_FALSE(C->isOriginal());
   EXPECT_TRUE(C->isDetached());
 
   auto *S = syntax::createEmptyStatement(*Arena);
   ASSERT_NE(S, nullptr);
   EXPECT_TRUE(S->canModify());
   EXPECT_FALSE(S->isOriginal());
   EXPECT_TRUE(S->isDetached());
 }
 
 } // namespace