[Syntax] Remove a strict valid source location assertion for TypeLoc.

[hokein]

Summary

The EndLoc of a type loc can be invalid for broken code.

Also extend the existing test to support error code with error-ok
annotation.

clang/lib/Tooling/Syntax/BuildTree.cpp

 ///     `int *a = nullptr` -> range of `*a = nullptr`.
 ///     `int S::f(){}` -> range of `S::f()`.
 /// FIXME: \p Name must be a source range.
 static SourceRange getDeclaratorRange(const SourceManager &SM, TypeLoc T,
                                       SourceLocation Name,
                                       SourceRange Initializer) {
   SourceLocation Start = GetStartLoc().Visit(T);
   SourceLocation End = T.getEndLoc();
-  assert(End.isValid());
   if (Name.isValid()) {
     if (Start.isInvalid())
       Start = Name;
-    if (SM.isBeforeInTranslationUnit(End, Name))
+    // End of TypeLoc could be invalid if the type is invalid, fallback to the
+    // NameLoc.
+    if (End.isInvalid() || SM.isBeforeInTranslationUnit(End, Name))
       End = Name;
   }
   if (Initializer.isValid()) {
     auto InitializerEnd = Initializer.getEnd();
     assert(SM.isBeforeInTranslationUnit(End, InitializerEnd) ||
            End == InitializerEnd);
     End = InitializerEnd;
   }

clang/unittests/Tooling/Syntax/BuildTreeTest.cpp

 namespace {
 
 class BuildSyntaxTreeTest : public SyntaxTreeTest {
 protected:
   ::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree) {
     SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
 
     auto *Root = buildTree(Code, GetParam());
-    if (Diags->getClient()->getNumErrors() != 0) {
-      return ::testing::AssertionFailure()
-             << "Source file has syntax errors, they were printed to the test "
-                "log";
-    }
+    auto ErrorOK = errorOK(Code);
+    if (!ErrorOK)
+      return ErrorOK;
     auto Actual = StringRef(Root->dump(Arena->getSourceManager())).trim().str();
     // EXPECT_EQ shows the diff between the two strings if they are different.
     EXPECT_EQ(Tree.trim().str(), Actual);
     if (Actual != Tree.trim().str()) {
       return ::testing::AssertionFailure();
     }
     return ::testing::AssertionSuccess();
   }
 
   ::testing::AssertionResult
   treeDumpEqualOnAnnotations(StringRef CodeWithAnnotations,
                              ArrayRef<StringRef> TreeDumps) {
     SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
 
     auto AnnotatedCode = llvm::Annotations(CodeWithAnnotations);
     auto *Root = buildTree(AnnotatedCode.code(), GetParam());
 
-    if (Diags->getClient()->getNumErrors() != 0) {
-      return ::testing::AssertionFailure()
-             << "Source file has syntax errors, they were printed to the test "
-                "log";
-    }
+    auto ErrorOK = errorOK(AnnotatedCode.code());
+    if (!ErrorOK)
+      return ErrorOK;
 
     auto AnnotatedRanges = AnnotatedCode.ranges();
     if (AnnotatedRanges.size() != TreeDumps.size()) {
       return ::testing::AssertionFailure()
              << "The number of annotated ranges in the source code is "
                 "different "
                 "to the number of their corresponding tree dumps.";
     }
for (unsigned i = 0; i < AnnotatedRanges.size(); i++) {
           << AnnotatedCode.code().slice(AnnotatedRanges[i].Begin,
                                         AnnotatedRanges[i].End);
       if (AnnotatedNodeDump != TreeDumps[i].trim().str())
         Failed = true;
     }
     return Failed ? ::testing::AssertionFailure()
                   : ::testing::AssertionSuccess();
   }
+
+private:
+  ::testing::AssertionResult errorOK(StringRef RawCode) {
+    if (!RawCode.contains("error-ok")) {
+      if (Diags->getClient()->getNumErrors() != 0) {
+        return ::testing::AssertionFailure()
+               << "Source file has syntax errors (suppress with /*error-ok*/), "
+                  "they were printed to the "
+                  "test log";
+      }
+    }
+    return ::testing::AssertionSuccess();
+  }
 };
 
 INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, BuildSyntaxTreeTest,
                         testing::ValuesIn(allTestClangConfigs()), );
 
 TEST_P(BuildSyntaxTreeTest, Simple) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(

 }
 
 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Named) {
   EXPECT_TRUE(treeDumpEqualOnAnnotations(
       R"cpp(
      int func1([[int a]]);
      int func2([[int *ap]]);
      int func3([[int a, float b]]);
+     int func4([[undef a]]); // error-ok: no crash on invalid type
    )cpp",
       {R"txt(
 ParameterDeclarationList Parameters
 `-SimpleDeclaration ListElement
   |-'int'
   `-DeclaratorList Declarators
     `-SimpleDeclarator ListElement
       `-'a'

 |   `-SimpleDeclarator ListElement
 |     `-'a'
 |-',' ListDelimiter
 `-SimpleDeclaration ListElement
   |-'float'
   `-DeclaratorList Declarators
     `-SimpleDeclarator ListElement
       `-'b'
+)txt",
+       R"txt(
+ParameterDeclarationList Parameters
+`-SimpleDeclaration ListElement
+  |-'undef'
+  `-DeclaratorList Declarators
+    `-SimpleDeclarator ListElement
+      `-'a'
 )txt"}));
 }
 
 TEST_P(BuildSyntaxTreeTest, ParametersAndQualifiers_InFreeFunctions_Unnamed) {
   EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(int);
 int func2(int *);