Reorder ASTNodeKind::AllKindInfo to match NodeKindId.

[alexfh]

Summary

AllKindInfo is being indexed by NodeKindId, so the order must match.
I've updated the tests, though I'm not sure what exactly they verify and whether
the new state of the tests makes sense ;)

I can add dedicated tests for this change, if needed.

[alexfh]

• Added a test

[sbenza]

Those tests are testing the code completion you get in clang-query.
The type list must match what that matcher supports.

hasParent is declared as

const internal::ArgumentAdaptingMatcherFunc<
    internal::HasParentMatcher,
    internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>,
    internal::TypeList<Decl, NestedNameSpecifierLoc, Stmt, TypeLoc>>
    LLVM_ATTRIBUTE_UNUSED hasParent = {};

so the completion message is correct now.

unittests/AST/ASTTypeTraitsTest.cpp

118 ↗

(On Diff #53566)

Add a derived Decl type too.
You added one for Stmt and Type, but not for Decl.

[alexfh]

Added a Decl descendant for a test.

[Prazek]

Does it solve my problem with isInTemplateInstantiation? :)

[alexfh]

No, but I'm working on the solution.

cfe/trunk/lib/AST/ASTTypeTraits.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 
 namespace clang {
 namespace ast_type_traits {
 
 const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = {
   { NKI_None, "<None>" },
-  { NKI_None, "CXXCtorInitializer" },
   { NKI_None, "TemplateArgument" },
-  { NKI_None, "NestedNameSpecifier" },
   { NKI_None, "NestedNameSpecifierLoc" },
   { NKI_None, "QualType" },
   { NKI_None, "TypeLoc" },
+  { NKI_None, "CXXCtorInitializer" },
+  { NKI_None, "NestedNameSpecifier" },
   { NKI_None, "Decl" },
 #define DECL(DERIVED, BASE) { NKI_##BASE, #DERIVED "Decl" },
 #include "clang/AST/DeclNodes.inc"
   { NKI_None, "Stmt" },
 #define STMT(DERIVED, BASE) { NKI_##BASE, #DERIVED },
 #include "clang/AST/StmtNodes.inc"
   { NKI_None, "Type" },
 #define TYPE(DERIVED, BASE) { NKI_##BASE, #DERIVED "Type" },

cfe/trunk/unittests/AST/ASTTypeTraitsTest.cpp

 struct Foo {};
 
 TEST(ASTNodeKind, UnknownKind) {
   // We can construct one, but it is nowhere in the hierarchy.
   EXPECT_FALSE(DNT<Foo>().isSame(DNT<Foo>()));
 }
 
 TEST(ASTNodeKind, Name) {
-  EXPECT_EQ("Decl", DNT<Decl>().asStringRef());
-  EXPECT_EQ("CallExpr", DNT<CallExpr>().asStringRef());
-  EXPECT_EQ("ConstantArrayType", DNT<ConstantArrayType>().asStringRef());
   EXPECT_EQ("<None>", ASTNodeKind().asStringRef());
+#define VERIFY_NAME(Node) EXPECT_EQ(#Node, DNT<Node>().asStringRef());
+  VERIFY_NAME(TemplateArgument);
+  VERIFY_NAME(NestedNameSpecifierLoc);
+  VERIFY_NAME(QualType);
+  VERIFY_NAME(TypeLoc);
+  VERIFY_NAME(CXXCtorInitializer);
+  VERIFY_NAME(NestedNameSpecifier);
+  VERIFY_NAME(Decl);
+  VERIFY_NAME(CXXRecordDecl);
+  VERIFY_NAME(Stmt);
+  VERIFY_NAME(CallExpr);
+  VERIFY_NAME(Type);
+  VERIFY_NAME(ConstantArrayType);
+#undef VERIFY_NAME
 }
 
 TEST(DynTypedNode, DeclSourceRange) {
   RangeVerifier<DynTypedNode> Verifier;
   Verifier.expectRange(1, 1, 1, 11);
   EXPECT_TRUE(Verifier.match("void f() {}", decl()));
 }
 

cfe/trunk/unittests/ASTMatchers/Dynamic/ParserTest.cpp

TEST(ParserTest, CompletionNamedValues) {
   EXPECT_EQ("arameter(", Comps[1].TypedText);
   EXPECT_EQ(
       "Matcher<FunctionDecl> hasParameter(unsigned, Matcher<ParmVarDecl>)",
       Comps[1].MatcherDecl);
 
   EXPECT_EQ("arent(", Comps[2].TypedText);
   EXPECT_EQ(
       "Matcher<Decl> "
-      "hasParent(Matcher<TemplateArgument|NestedNameSpecifierLoc|Decl|...>)",
+      "hasParent(Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...>)",
       Comps[2].MatcherDecl);
 }
 
 }  // end anonymous namespace
 }  // end namespace dynamic
 }  // end namespace ast_matchers
 }  // end namespace clang

cfe/trunk/unittests/ASTMatchers/Dynamic/RegistryTest.cpp

EXPECT_EQ("Incorrect type for arg 1. "
             Error->toString());
 }
 
 TEST_F(RegistryTest, Completion) {
   CompVector Comps = getCompletions();
   // Overloaded
   EXPECT_TRUE(hasCompletion(
       Comps, "hasParent(",
-      "Matcher<TemplateArgument|NestedNameSpecifierLoc|Decl|...> "
-      "hasParent(Matcher<TemplateArgument|NestedNameSpecifierLoc|Decl|...>)"));
+      "Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...> "
+      "hasParent(Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...>)"));
   // Variadic.
   EXPECT_TRUE(hasCompletion(Comps, "whileStmt(",
                             "Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)"));
   // Polymorphic.
   EXPECT_TRUE(hasCompletion(
       Comps, "hasDescendant(",
-      "Matcher<TemplateArgument|NestedNameSpecifier|NestedNameSpecifierLoc|...>"
-      " hasDescendant(Matcher<TemplateArgument|NestedNameSpecifier|"
-      "NestedNameSpecifierLoc|...>)"));
+      "Matcher<NestedNameSpecifierLoc|QualType|TypeLoc|...> "
+      "hasDescendant(Matcher<NestedNameSpecifierLoc|QualType|TypeLoc|...>)"));
 
   CompVector WhileComps = getCompletions("whileStmt", 0);
 
   EXPECT_TRUE(hasCompletion(WhileComps, "hasBody(",
                             "Matcher<WhileStmt> hasBody(Matcher<Stmt>)"));
-  EXPECT_TRUE(hasCompletion(WhileComps, "hasParent(",
-                            "Matcher<Stmt> "
-                            "hasParent(Matcher<TemplateArgument|"
-                            "NestedNameSpecifierLoc|Decl|...>)"));
+  EXPECT_TRUE(hasCompletion(
+      WhileComps, "hasParent(",
+      "hasParent(Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...>)"));
   EXPECT_TRUE(
       hasCompletion(WhileComps, "allOf(", "Matcher<T> allOf(Matcher<T>...)"));
 
   EXPECT_FALSE(hasCompletion(WhileComps, "whileStmt("));
   EXPECT_FALSE(hasCompletion(WhileComps, "ifStmt("));
 
   CompVector AllOfWhileComps =
       getCompletions("allOf", 0, "whileStmt", 0);