[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

106

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

128

s/SkipWindows/RunWithDelayedTemplateParsing/ ?

136

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.

802

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

syntax::TranslationUnit *buildTree(llvm::StringRef Code) {
     };
 
     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",
+                                      // Hard-setting target so the unit test
+                                      // behavior doesn't depend on the host.
+                                      "-target", "x86_64-unknown-unknown",
                                       "-fsyntax-only", 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;
   }
 
   // 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;
     }
   }
 
   /// Finds the deepest node in the tree that covers exactly \p R.
`-SimpleDeclaration
     |   |-(
     |   `-)
     `-CompoundStatement
       |-{
       `-}
 )txt");
 }
 
 TEST_F(SyntaxTreeTest, NestedTemplates) {
   expectTreeDumpEqual(
       R"cpp(
 template <class T>
 struct X {
   template <class U>
   U foo();
 };
     )cpp",