[ASTMatchers] Add `isConstinit` matcher

[Izaron]

Summary

Support C++20 constinit variables for AST Matchers.

[Izaron]

I'm going to use this matcher very soon in my new clang-tidy check.

If you're interested and want to read more, I have a design document about my ne check - here (gist.github.com) is the concrete check for constinit variables.

I think an ASTMatcher would be good, because:

1. As far I tried there is no way to get only constinit variables in clang-query (?)
2. The way to check in code if a variable is constinit is not quite obvious. A user may expect Node.isConstinit() (because Node.isConstexpr() works), but it's not working. The user has to examine AST and grep until they find Node.hasAttr<ConstInitAttr>().

P. S. If this commit will be accepted, kindly please commit it on my behalf, because I can't do it =) You can use my name Evgeny Shulgin and [e-mail]

[Izaron]

Removed the brackets in { return }

[Izaron]

Fix clang-format

[aaron.ballman]

clang/include/clang/ASTMatchers/ASTMatchers.h

5223

This isn't quite correct -- there are two forms of ConstInitAttr:

constinit int i = 0; // We want to match this one
[[clang::require_constant_initialization]] int j = 0; // We don't want to match this one

We typically want AST matchers to model the AST and this one does not... but, I think it is okay. constinit was based on the implementation experience we got with [[clang::require_constant_initialization]] and so we continue to model it as an attribute rather than a bit on the AST node. Having this matcher helps to distinguish the cases (otherwise we could just use the hasAttr() matcher instead).

I think the logic here should be:

if (const auto *CIA = Node.getAttr<ConstInitAttr>())
  return CIA->isConstinit();
return false;

and you should add a test case + documentation to show that we don't match the attribute form.

[Izaron]

Fix: accept only keyword, not the attribute itself

[Izaron]

clang/include/clang/ASTMatchers/ASTMatchers.h

5223

Thank you! Very valuable information. It opened my eyes why is constinit unexpectedly parsed like an attribute. Another plus of the new matcher - users won't search for constinit incorrectly as I did before the fix.

I added an explicit example to docs showing that the clang attribute won't work.

[aaron.ballman]

LGTM!

[aaron.ballman]

I've commit on your behalf in 589a93907222cf2380198ca2172ff6697dd43d87, thanks for the new matcher!

clang/docs/LibASTMatchersReference.html

varDecl(isConstexpr())
   matches the declaration of foo.
 functionDecl(isConstexpr())
   matches the declaration of bar.
 ifStmt(isConstexpr())
   matches the if statement in baz.
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isConstinit0')"><a name="isConstinit0Anchor">isConstinit</a></td><td></td></tr>
+<tr><td colspan="4" class="doc" id="isConstinit0"><pre>Matches constinit variable declarations.
+
+Given:
+  constinit int foo = 42;
+  constinit const char* bar = "baz";
+  int baz = 42;
+  [[clang::require_constant_initialization]] int xyz = 42;
+varDecl(isConstinit())
+  matches the declaration of `foo` and `bar`, but not `baz` and `xyz`.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;</td><td class="name" onclick="toggle('isDefinition1')"><a name="isDefinition1Anchor">isDefinition</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isDefinition1"><pre>Matches if a declaration has a body attached.
 
 Example matches A, va, fa
   class A {};
   class B;  // Doesn't match, as it has no body.
   int va;
   extern int vb;  // Doesn't match, as it doesn't define the variable.

clang/docs/ReleaseNotes.rst

 - The ``usingType`` matcher is now available and needed to refer to types that
   are referred to via using C++ using declarations.
   The associated ``UsingShadowDecl`` can be matched using ``throughUsingDecl``
   and the underlying ``Type`` with ``hasUnderlyingType``.
   ``hasDeclaration`` continues to see through the alias and apply to the
   underlying type.
 - Added the ``isConsteval`` matcher to match ``consteval`` function
   declarations as well as `if consteval` and `if ! consteval` statements.
+- Added the ``isConstinit`` matcher to match ``constinit`` variable
+  declarations.
 
 clang-format
 ------------
 
 - Option ``AllowShortEnumsOnASingleLine: false`` has been improved, it now
   correctly places the opening brace according to ``BraceWrapping.AfterEnum``.
 
 - Option ``AlignAfterOpenBracket: BlockIndent`` has been added. If set, it will

clang/include/clang/ASTMatchers/ASTMatchers.h

 ///   matches the if statement in baz.
 AST_POLYMORPHIC_MATCHER(isConstexpr,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(VarDecl,
                                                         FunctionDecl,
                                                         IfStmt)) {
   return Node.isConstexpr();
 }
 
+/// Matches constinit variable declarations.
+///
+/// Given:
+/// \code
+///   constinit int foo = 42;
+///   constinit const char* bar = "bar";
+///   int baz = 42;
+///   [[clang::require_constant_initialization]] int xyz = 42;
+/// \endcode
+/// varDecl(isConstinit())
+///   matches the declaration of `foo` and `bar`, but not `baz` and `xyz`.
+AST_MATCHER(VarDecl, isConstinit) {
+  if (const auto *CIA = Node.getAttr<ConstInitAttr>())
+    return CIA->isConstinit();
+  return false;
+}
+
 /// Matches selection statements with initializer.
 ///
 /// Given:
 /// \code
 ///  void foo() {
 ///    if (int i = foobar(); i > 0) {}
 ///    switch (int i = foobar(); i) {}
 ///    for (auto& a = get_range(); auto& x : a) {}

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(isClass);
   REGISTER_MATCHER(isClassMessage);
   REGISTER_MATCHER(isClassMethod);
   REGISTER_MATCHER(isComparisonOperator);
   REGISTER_MATCHER(isConst);
   REGISTER_MATCHER(isConstQualified);
   REGISTER_MATCHER(isConsteval);
   REGISTER_MATCHER(isConstexpr);
+  REGISTER_MATCHER(isConstinit);
   REGISTER_MATCHER(isCopyAssignmentOperator);
   REGISTER_MATCHER(isCopyConstructor);
   REGISTER_MATCHER(isDefaultConstructor);
   REGISTER_MATCHER(isDefaulted);
   REGISTER_MATCHER(isDefinition);
   REGISTER_MATCHER(isDelegatingConstructor);
   REGISTER_MATCHER(isDeleted);
   REGISTER_MATCHER(isEnum);

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST_P(ASTMatchersTest, IsConstexpr_MatchesIfConstexpr) {
   }
 
   EXPECT_TRUE(
       matches("void baz() { if constexpr(1 > 0) {} }", ifStmt(isConstexpr())));
   EXPECT_TRUE(
       notMatches("void baz() { if (1 > 0) {} }", ifStmt(isConstexpr())));
 }
 
+TEST_P(ASTMatchersTest, IsConstinit) {
+  if (!GetParam().isCXX20OrLater())
+    return;
+
+  EXPECT_TRUE(matches("constinit int foo = 1;",
+                      varDecl(hasName("foo"), isConstinit())));
+  EXPECT_TRUE(matches("extern constinit int foo;",
+                      varDecl(hasName("foo"), isConstinit())));
+  EXPECT_TRUE(matches("constinit const char* foo = \"bar\";",
+                      varDecl(hasName("foo"), isConstinit())));
+  EXPECT_TRUE(
+      notMatches("[[clang::require_constant_initialization]] int foo = 1;",
+                 varDecl(hasName("foo"), isConstinit())));
+  EXPECT_TRUE(notMatches("constexpr int foo = 1;",
+                         varDecl(hasName("foo"), isConstinit())));
+  EXPECT_TRUE(notMatches("static inline int foo = 1;",
+                         varDecl(hasName("foo"), isConstinit())));
+}
+
 TEST_P(ASTMatchersTest, HasInitStatement_MatchesSelectionInitializers) {
   EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }",
                          ifStmt(hasInitStatement(anything()))));
   EXPECT_TRUE(notMatches("void baz(int i) { switch (i) { default: break; } }",
                          switchStmt(hasInitStatement(anything()))));
 }
 
 TEST_P(ASTMatchersTest, HasInitStatement_MatchesSelectionInitializers_CXX) {