[ASTMatchers] The `isInline` matcher now accepts inline variables

[Izaron]

Summary

Inline variables is a feature from C++17. It makes sense
to extend the isInline matcher in order to support corresponding varDecls.

[Izaron]

I am planning to reuse this matcher in my new checker (https://reviews.llvm.org/D118743, under development now), removing this line:

AST_MATCHER(VarDecl, isVarInline) { return Node.isInline(); }

P.S. If this review is eventually approved, kindly please merge the commit on my behalf =) As I don't have merge access. My name is Evgeny Shulgin and email is [e-mail]. Sorry for inconvenience!

[Izaron]

clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp

195–201

Isn't this test equivalent to the new one I wrote in the other file? The difference between TEST and TEST_P I see is that the latter one allows you to check C++17 code, while the former does not. So I decided to have all checks in one place.

[njames93]

I had the same idea in D118900

[Izaron]

In D118922#3296542, @njames93 wrote:

I had the same idea in D118900

Wow! That's a curious coincidence. I'm closing my PR =) Let it be your version as the earlier one.

clang/docs/LibASTMatchersReference.html

 functionDecl(isExternC())
   matches the declaration of f and g, but not the declaration of h.
 varDecl(isExternC())
   matches the declaration of x and y, but not the declaration of z.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isInline1')"><a name="isInline1Anchor">isInline</a></td><td></td></tr>
-<tr><td colspan="4" class="doc" id="isInline1"><pre>Matches function and namespace declarations that are marked with
+<tr><td colspan="4" class="doc" id="isInline1"><pre>Matches variable, function and namespace declarations that are marked with
 the inline keyword.
 
 Given
+  inline constexpr int i = 1;
   inline void f();
   void g();
   namespace n {
   inline namespace m {}
   }
+varDecl(isInline()) will match ::i.
 functionDecl(isInline()) will match ::f().
 namespaceDecl(isInline()) will match n::m.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isMain0')"><a name="isMain0Anchor">isMain</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isMain0"><pre>Determines whether the function is "main", which is the entry point
 into an executable program.

 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt;</td><td class="name" onclick="toggle('isInline0')"><a name="isInline0Anchor">isInline</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isInline0"><pre>Matches function and namespace declarations that are marked with
 the inline keyword.
 
 Given
+  inline constexpr int i = 1;
   inline void f();
   void g();
   namespace n {
   inline namespace m {}
   }
+varDecl(isInline()) will match ::i.
 functionDecl(isInline()) will match ::f().
 namespaceDecl(isInline()) will match n::m.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isFirstPrivateKind0')"><a name="isFirstPrivateKind0Anchor">isFirstPrivateKind</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isFirstPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``firstprivate`` kind
 specified.

 <tr><td colspan="4" class="doc" id="isInitCapture0"><pre>Matches a variable serving as the implicit variable for a lambda init-
 capture.
 
 Example matches x (matcher = varDecl(isInitCapture()))
 auto f = [x=3]() { return x; };
 </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('isInline2')"><a name="isInline2Anchor">isInline</a></td><td></td></tr>
+<tr><td colspan="4" class="doc" id="isInline2"><pre>Matches variable, function and namespace declarations that are marked with
+the inline keyword.
+
+Given
+  inline constexpr int i = 1;
+  inline void f();
+  void g();
+  namespace n {
+  inline namespace m {}
+  }
+varDecl(isInline()) will match ::i.
+functionDecl(isInline()) will match ::f().
+namespaceDecl(isInline()) will match n::m.
+</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('isStaticLocal0')"><a name="isStaticLocal0Anchor">isStaticLocal</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isStaticLocal0"><pre>Matches a static variable with local scope.
 
 Example matches y (matcher = varDecl(isStaticLocal()))
 void f() {
   int x;
   static int y;
 }

clang/docs/ReleaseNotes.rst

 --------------------
 
 Build System Changes
 --------------------
 
 AST Matchers
 ------------
 
+- The ``isInline`` matcher now accepts inline variable declarations.
+
 clang-format
 ------------
 
 libclang
 --------
 
 - ...
 

clang/include/clang/ASTMatchers/ASTMatchers.h

AST_MATCHER_P(FunctionDecl, hasExplicitSpecifier, internal::Matcher<Expr>,
   if (!ES.getExpr())
     return false;
 
   ASTChildrenNotSpelledInSourceScope RAII(Finder, false);
 
   return InnerMatcher.matches(*ES.getExpr(), Finder, Builder);
 }
 
-/// Matches function and namespace declarations that are marked with
+/// Matches variable, function and namespace declarations that are marked with
 /// the inline keyword.
 ///
 /// Given
 /// \code
+///   inline constexpr int i = 1;
 ///   inline void f();
 ///   void g();
 ///   namespace n {
 ///   inline namespace m {}
 ///   }
 /// \endcode
+/// varDecl(isInline()) will match ::i.
 /// functionDecl(isInline()) will match ::f().
 /// namespaceDecl(isInline()) will match n::m.
 AST_POLYMORPHIC_MATCHER(isInline,
-                        AST_POLYMORPHIC_SUPPORTED_TYPES(NamespaceDecl,
-                                                        FunctionDecl)) {
+                        AST_POLYMORPHIC_SUPPORTED_TYPES(VarDecl, FunctionDecl,
+                                                        NamespaceDecl)) {
   // This is required because the spelling of the function used to determine
   // whether inline is specified or not differs between the polymorphic types.
-  if (const auto *FD = dyn_cast<FunctionDecl>(&Node))
+  if (const auto *VD = dyn_cast<VarDecl>(&Node))
+    return VD->isInline();
+  else if (const auto *FD = dyn_cast<FunctionDecl>(&Node))
     return FD->isInlineSpecified();
   else if (const auto *NSD = dyn_cast<NamespaceDecl>(&Node))
     return NSD->isInline();
   llvm_unreachable("Not a valid polymorphic type");
 }
 
 /// Matches anonymous namespace declarations.
 ///

clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp

 
 TEST(DynTypedMatcherTest, ConstructWithTraversalKindOverridesNestedTK) {
   auto M = DynTypedMatcher(decl()).withTraversalKind(TK_AsIs).withTraversalKind(
       TK_IgnoreUnlessSpelledInSource);
   EXPECT_THAT(M.getTraversalKind(),
               llvm::ValueIs(TK_IgnoreUnlessSpelledInSource));
 }
 
-TEST(IsInlineMatcher, IsInline) {
-  EXPECT_TRUE(matches("void g(); inline void f();",
-                      functionDecl(isInline(), hasName("f"))));
-  EXPECT_TRUE(matches("namespace n { inline namespace m {} }",
-                      namespaceDecl(isInline(), hasName("m"))));
-}
-
 // FIXME: Figure out how to specify paths so the following tests pass on
 // Windows.
 #ifndef _WIN32
 
 TEST(Matcher, IsExpansionInMainFileMatcher) {
   EXPECT_TRUE(matches("class X {};",
                       recordDecl(hasName("X"), isExpansionInMainFile())));
   EXPECT_TRUE(notMatches("", recordDecl(isExpansionInMainFile())));

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST_P(ASTMatchersTest, IsInitCapture) {
   if (!GetParam().isCXX14OrLater()) {
     return;
   }
   EXPECT_TRUE(matches("int main() { auto f = [vd=3]() { return vd; }; }", M));
   EXPECT_TRUE(matches(
       "int main() { int x = 3; auto f = [vd=x]() { return vd; }; }", M));
 }
 
+TEST_P(ASTMatchersTest, IsInline) {
+  if (!GetParam().isCXX() && !GetParam().isC99OrLater())
+    return;
+  EXPECT_TRUE(matches("void g(); inline void f();",
+                      functionDecl(isInline(), hasName("f"))));
+
+  if (!GetParam().isCXX())
+    return;
+  EXPECT_TRUE(matches("namespace n { inline namespace m {} }",
+                      namespaceDecl(isInline(), hasName("m"))));
+
+  if (!GetParam().isCXX17OrLater())
+    return;
+  EXPECT_TRUE(matches("inline constexpr int i = 1;",
+                      varDecl(isInline(), hasName("i"))));
+}
+
 TEST_P(ASTMatchersTest, StorageDuration) {
   StringRef T =
       "void f() { int x; static int y; } int a;static int b;extern int c;";
 
   EXPECT_TRUE(matches(T, varDecl(hasName("x"), hasAutomaticStorageDuration())));
   EXPECT_TRUE(
       notMatches(T, varDecl(hasName("y"), hasAutomaticStorageDuration())));
   EXPECT_TRUE(