[ASTMatchers] basic matcher support for ConceptReference

[sammccall]

Summary

This adds only the trivial conceptReference() matcher.
(Also adds tests for ConceptReference in DynTypedNode, which need this
matcher)

This node isn't part of any other inheritance hierarchy, so it meant
handling a new base type everywhere.

This caused us to run out of discriminator bits in the CurMatchData,
so I replaced the data structure with std::variant which is at least
less code.

[massberg]

clang/docs/LibASTMatchersReference.html

2545

Was this change to drop the () by purpose?

2559

same as above

[sammccall]

(by mail as phab is unusable today)

[sammccall]

regenerate HTML after rebasing on 415d9e8ca39c0b42f351cc532ccfb48b6ac97f7f

[aaron.ballman]

LGTM as well btw -- @sammccall, it looks like this one may have fallen off your radar? (Please add a release note when landing though; we have a section for AST matchers specifically.)

clang/docs/LibASTMatchersReference.html

 Examples matches i(42).
   class C {
     C() : i(42) {}
     int i;
   };
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConceptReference.html">ConceptReference</a>&gt;</td><td class="name" onclick="toggle('conceptReference0')"><a name="conceptReference0Anchor">conceptReference</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConceptReference.html">ConceptReference</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="conceptReference0"><pre>Matches concept references.
+
+Given
+  template &lt;class&gt; concept C = true;
+  bool X = C&lt;int&gt;;
+conceptReference()
+  matches 'C&lt;int&gt;'.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('accessSpecDecl0')"><a name="accessSpecDecl0Anchor">accessSpecDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AccessSpecDecl.html">AccessSpecDecl</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="accessSpecDecl0"><pre>Matches C++ access specifier declarations.
 
 Given
   class C {
   public:
     int a;
   };

 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentSizedArrayType0')"><a name="dependentSizedArrayType0Anchor">dependentSizedArrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedArrayType.html">DependentSizedArrayType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
 
 Given
   template&lt;typename T, int Size&gt;
   class array {
     T data[Size];
   };
 dependentSizedArrayType()
   matches "T data[Size]"
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentSizedExtVectorType0')"><a name="dependentSizedExtVectorType0Anchor">dependentSizedExtVectorType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedExtVectorType.html">DependentSizedExtVectorType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="dependentSizedExtVectorType0"><pre>Matches C++ extended vector type where either the type or size is
 dependent.
 
 Given
   template&lt;typename T, int Size&gt;
   class vector {
     typedef T __attribute__((ext_vector_type(Size))) type;
   };
 dependentSizedExtVectorType()
   matches "T __attribute__((ext_vector_type(Size)))"
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('elaboratedType0')"><a name="elaboratedType0Anchor">elaboratedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
 qualified name.
 

clang/include/clang/ASTMatchers/ASTMatchFinder.h

void addMatcher(const NestedNameSpecifierLocMatcher &NodeMatch,
                   MatchCallback *Action);
   void addMatcher(const TypeLocMatcher &NodeMatch,
                   MatchCallback *Action);
   void addMatcher(const CXXCtorInitializerMatcher &NodeMatch,
                   MatchCallback *Action);
   void addMatcher(const TemplateArgumentLocMatcher &NodeMatch,
                   MatchCallback *Action);
   void addMatcher(const AttrMatcher &NodeMatch, MatchCallback *Action);
+  void addMatcher(const ConceptReferenceMatcher &NodeMatch,
+                  MatchCallback *Action);
   /// @}
 
   /// Adds a matcher to execute when running over the AST.
   ///
   /// This is similar to \c addMatcher(), but it uses the dynamic interface. It
   /// is more flexible, but the lost type information enables a caller to pass
   /// a matcher that cannot match anything.
   ///
std::vector<std::pair<NestedNameSpecifierMatcher, MatchCallback *>>
         NestedNameSpecifier;
     std::vector<std::pair<NestedNameSpecifierLocMatcher, MatchCallback *>>
         NestedNameSpecifierLoc;
     std::vector<std::pair<TypeLocMatcher, MatchCallback *>> TypeLoc;
     std::vector<std::pair<CXXCtorInitializerMatcher, MatchCallback *>> CtorInit;
     std::vector<std::pair<TemplateArgumentLocMatcher, MatchCallback *>>
         TemplateArgumentLoc;
     std::vector<std::pair<AttrMatcher, MatchCallback *>> Attr;
+    std::vector<std::pair<ConceptReferenceMatcher, MatchCallback *>>
+        ConceptReference;
     /// All the callbacks in one container to simplify iteration.
     llvm::SmallPtrSet<MatchCallback *, 16> AllCallbacks;
   };
 
 private:
   MatchersByType Matchers;
 
   MatchFinderOptions Options;

clang/include/clang/ASTMatchers/ASTMatchers.h

 using NestedNameSpecifierMatcher = internal::Matcher<NestedNameSpecifier>;
 using NestedNameSpecifierLocMatcher = internal::Matcher<NestedNameSpecifierLoc>;
 using CXXBaseSpecifierMatcher = internal::Matcher<CXXBaseSpecifier>;
 using CXXCtorInitializerMatcher = internal::Matcher<CXXCtorInitializer>;
 using TemplateArgumentMatcher = internal::Matcher<TemplateArgument>;
 using TemplateArgumentLocMatcher = internal::Matcher<TemplateArgumentLoc>;
 using LambdaCaptureMatcher = internal::Matcher<LambdaCapture>;
 using AttrMatcher = internal::Matcher<Attr>;
+using ConceptReferenceMatcher = internal::Matcher<ConceptReference>;
 /// @}
 
 /// Matches any node.
 ///
 /// Useful when another matcher requires a child matcher, but there's no
 /// additional constraint. This will often be used with an explicit conversion
 /// to an \c internal::Matcher<> type such as \c TypeMatcher.
 ///

 ///   template <template <typename> class Z, int N> struct C {};
 /// \endcode
 /// templateTypeParmDecl()
 ///   matches 'Z', but not 'N'.
 extern const internal::VariadicDynCastAllOfMatcher<Decl,
                                                    TemplateTemplateParmDecl>
     templateTemplateParmDecl;
 
+/// Matches concept references.
+///
+/// Given
+/// \code
+///   template <class> concept C = true;
+///   bool X = C<int>;
+/// \endcode
+/// conceptReference()
+///   matches 'C<int>'.
+extern const internal::VariadicAllOfMatcher<ConceptReference> conceptReference;
+
+
 /// Matches public C++ declarations and C++ base specifers that specify public
 /// inheritance.
 ///
 /// Examples:
 /// \code
 ///   class C {
 ///   public:    int a; // fieldDecl(isPublic()) matches 'a'
 ///   protected: int b;

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

return Node != nullptr &&
            this->InnerMatcher.matches(DynTypedNode::create(*Node), Finder,
                                       Builder);
   }
 };
 
 /// IsBaseType<T>::value is true if T is a "base" type in the AST
 /// node class hierarchies.
 template <typename T>
-struct IsBaseType {
-  static const bool value =
-      std::is_same<T, Decl>::value || std::is_same<T, Stmt>::value ||
-      std::is_same<T, QualType>::value || std::is_same<T, Type>::value ||
-      std::is_same<T, TypeLoc>::value ||
-      std::is_same<T, NestedNameSpecifier>::value ||
-      std::is_same<T, NestedNameSpecifierLoc>::value ||
-      std::is_same<T, CXXCtorInitializer>::value ||
-      std::is_same<T, TemplateArgumentLoc>::value ||
-      std::is_same<T, Attr>::value;
-};
-template <typename T>
-const bool IsBaseType<T>::value;
+using IsBaseType =
+    llvm::is_one_of<T, Decl, Stmt, QualType, Type, TypeLoc, NestedNameSpecifier,
+                    NestedNameSpecifierLoc, CXXCtorInitializer,
+                    TemplateArgumentLoc, Attr, ConceptReference>;
 
 /// A "type list" that contains all types.
 ///
 /// Useful for matchers like \c anything and \c unless.
 using AllNodeBaseTypes =
     TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, QualType,
              Type, TypeLoc, CXXCtorInitializer, Attr>;
 

clang/lib/ASTMatchers/ASTMatchFinder.cpp

 #include "clang/AST/RecursiveASTVisitor.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Timer.h"
 #include <deque>
 #include <memory>
 #include <set>
+#include <variant>
 
 namespace clang {
 namespace ast_matchers {
 namespace internal {
 namespace {
 
 typedef MatchFinder::MatchCallback MatchCallback;
 
else if (const TypeLoc *T = DynNode.get<TypeLoc>())
       traverse(*T);
     else if (const auto *C = DynNode.get<CXXCtorInitializer>())
       traverse(*C);
     else if (const TemplateArgumentLoc *TALoc =
                  DynNode.get<TemplateArgumentLoc>())
       traverse(*TALoc);
     else if (const Attr *A = DynNode.get<Attr>())
       traverse(*A);
+    else if (const ConceptReference *CR = DynNode.get<ConceptReference>())
+      traverse(*CR);
     // FIXME: Add other base types after adding tests.
 
     // It's OK to always overwrite the bound nodes, as if there was
     // no match in this recursive branch, the result set is empty
     // anyway.
     *Builder = ResultBindings;
 
     return Matches;
bool TraverseAttr(Attr *A) {
     if (A == nullptr ||
         (A->isImplicit() &&
          Finder->getASTContext().getParentMapContext().getTraversalKind() ==
              TK_IgnoreUnlessSpelledInSource))
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
     return traverse(*A);
   }
+  bool TraverseConceptReference(ConceptReference *CR) {
+    if (CR == nullptr)
+      return true;
+    ScopedIncrement ScopedDepth(&CurrentDepth);
+    return traverse(*CR);
+  }
   bool TraverseLambdaExpr(LambdaExpr *Node) {
     if (!Finder->isTraversalIgnoringImplicitNodes())
       return VisitorBase::TraverseLambdaExpr(Node);
     if (!Node)
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
 
     for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
return VisitorBase::TraverseConstructorInitializer(
         const_cast<CXXCtorInitializer *>(&CtorInit));
   }
   bool baseTraverse(TemplateArgumentLoc TAL) {
     return VisitorBase::TraverseTemplateArgumentLoc(TAL);
   }
   bool baseTraverse(const Attr &AttrNode) {
     return VisitorBase::TraverseAttr(const_cast<Attr *>(&AttrNode));
   }
+  bool baseTraverse(const ConceptReference &CR) {
+    return VisitorBase::TraverseConceptReference(
+        const_cast<ConceptReference *>(&CR));
+  }
 
   // Sets 'Matched' to true if 'Matcher' matches 'Node' and:
   //   0 < CurrentDepth <= MaxDepth.
   //
   // Returns 'true' if traversal should continue after this function
   // returns, i.e. if no match is found or 'Bind' is 'BK_All'.
   template <typename T>
   bool match(const T &Node) {
public:
   bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr);
   bool TraverseType(QualType TypeNode);
   bool TraverseTypeLoc(TypeLoc TypeNode);
   bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
   bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit);
   bool TraverseTemplateArgumentLoc(TemplateArgumentLoc TAL);
   bool TraverseAttr(Attr *AttrNode);
+  bool TraverseConceptReference(ConceptReference *);
 
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue) {
     if (auto *RF = dyn_cast<CXXForRangeStmt>(S)) {
       {
         ASTNodeNotAsIsSourceScope RAII(this, true);
         TraverseStmt(RF->getInit());
         // Don't traverse under the loop variable
         match(*RF->getLoopVariable());
void match(const DynTypedNode &Node) {
     } else if (auto *N = Node.get<TypeLoc>()) {
       match(*N);
     } else if (auto *N = Node.get<CXXCtorInitializer>()) {
       match(*N);
     } else if (auto *N = Node.get<TemplateArgumentLoc>()) {
       match(*N);
     } else if (auto *N = Node.get<Attr>()) {
       match(*N);
+    } else if (auto *N = Node.get<ConceptReference>()) {
+      match(*N);
     }
   }
 
   template <typename T> void match(const T &Node) {
     matchDispatch(&Node);
   }
 
   // Implements ASTMatchFinder::getASTContext.
return RecursiveASTVisitor<MatchASTVisitor>::TraverseTemplateInstantiations(
         D);
   }
 
 private:
   bool TraversingASTNodeNotSpelledInSource = false;
   bool TraversingASTNodeNotAsIs = false;
   bool TraversingASTChildrenNotSpelledInSource = false;
 
-  class CurMatchData {
-// We don't have enough free low bits in 32bit builds to discriminate 8 pointer
-// types in PointerUnion. so split the union in 2 using a free bit from the
-// callback pointer.
-#define CMD_TYPES_0                                                            \
-  const QualType *, const TypeLoc *, const NestedNameSpecifier *,              \
-      const NestedNameSpecifierLoc *
-#define CMD_TYPES_1                                                            \
-  const CXXCtorInitializer *, const TemplateArgumentLoc *, const Attr *,       \
-      const DynTypedNode *
-
-#define IMPL(Index)                                                            \
-  template <typename NodeType>                                                 \
-  std::enable_if_t<                                                            \
-      llvm::is_one_of<const NodeType *, CMD_TYPES_##Index>::value>             \
-  SetCallbackAndRawNode(const MatchCallback *CB, const NodeType &N) {          \
-    assertEmpty();                                                             \
-    Callback.setPointerAndInt(CB, Index);                                      \
-    Node##Index = &N;                                                          \
-  }                                                                            \
-                                                                               \
-  template <typename T>                                                        \
-  std::enable_if_t<llvm::is_one_of<const T *, CMD_TYPES_##Index>::value,       \
-                   const T *>                                                  \
-  getNode() const {                                                            \
-    assertHoldsState();                                                        \
-    return Callback.getInt() == (Index) ? Node##Index.dyn_cast<const T *>()    \
-                                        : nullptr;                             \
-  }
-
-  public:
-    CurMatchData() : Node0(nullptr) {}
-
-    IMPL(0)
-    IMPL(1)
-
-    const MatchCallback *getCallback() const { return Callback.getPointer(); }
-
-    void SetBoundNodes(const BoundNodes &BN) {
-      assertHoldsState();
-      BNodes = &BN;
-    }
-
-    void clearBoundNodes() {
-      assertHoldsState();
-      BNodes = nullptr;
-    }
-
-    const BoundNodes *getBoundNodes() const {
-      assertHoldsState();
-      return BNodes;
-    }
-
-    void reset() {
-      assertHoldsState();
-      Callback.setPointerAndInt(nullptr, 0);
-      Node0 = nullptr;
-    }
-
-  private:
-    void assertHoldsState() const {
-      assert(Callback.getPointer() != nullptr && !Node0.isNull());
-    }
-
-    void assertEmpty() const {
-      assert(Callback.getPointer() == nullptr && Node0.isNull() &&
-             BNodes == nullptr);
-    }
-
-    llvm::PointerIntPair<const MatchCallback *, 1> Callback;
-    union {
-      llvm::PointerUnion<CMD_TYPES_0> Node0;
-      llvm::PointerUnion<CMD_TYPES_1> Node1;
-    };
+  struct CurMatchData {
+    const MatchCallback *Callback = nullptr;
     const BoundNodes *BNodes = nullptr;
-
-#undef CMD_TYPES_0
-#undef CMD_TYPES_1
-#undef IMPL
+    std::variant<std::monostate, const QualType *, const TypeLoc *,
+                 const NestedNameSpecifier *, const NestedNameSpecifierLoc *,
+                 const CXXCtorInitializer *, const TemplateArgumentLoc *,
+                 const Attr *, const DynTypedNode *, const ConceptReference *>
+        Node;
   } CurMatchState;
 
   struct CurMatchRAII {
     template <typename NodeType>
     CurMatchRAII(MatchASTVisitor &MV, const MatchCallback *CB,
                  const NodeType &NT)
         : MV(MV) {
-      MV.CurMatchState.SetCallbackAndRawNode(CB, NT);
+      assert(MV.CurMatchState.Callback == nullptr &&
+             std::holds_alternative<std::monostate>(MV.CurMatchState.Node) &&
+             MV.CurMatchState.BNodes == nullptr);
+      MV.CurMatchState.Callback = CB;
+      MV.CurMatchState.Node = &NT;
     }
 
-    ~CurMatchRAII() { MV.CurMatchState.reset(); }
+    ~CurMatchRAII() {
+      MV.CurMatchState.Callback = nullptr;
+      MV.CurMatchState.Node = std::monostate{};
+    }
 
   private:
     MatchASTVisitor &MV;
   };
 
 public:
   class TraceReporter : llvm::PrettyStackTraceEntry {
     static void dumpNode(const ASTContext &Ctx, const DynTypedNode &Node,
static void dumpNode(const ASTContext &Ctx, const DynTypedNode &Node,
       } else {
         OS << Node.getNodeKind().asStringRef() << " : ";
         Node.getSourceRange().print(OS, Ctx.getSourceManager());
       }
     }
 
     static void dumpNodeFromState(const ASTContext &Ctx,
                                   const CurMatchData &State, raw_ostream &OS) {
-      if (const DynTypedNode *MatchNode = State.getNode<DynTypedNode>()) {
-        dumpNode(Ctx, *MatchNode, OS);
-      } else if (const auto *QT = State.getNode<QualType>()) {
-        dumpNode(Ctx, DynTypedNode::create(*QT), OS);
-      } else if (const auto *TL = State.getNode<TypeLoc>()) {
-        dumpNode(Ctx, DynTypedNode::create(*TL), OS);
-      } else if (const auto *NNS = State.getNode<NestedNameSpecifier>()) {
-        dumpNode(Ctx, DynTypedNode::create(*NNS), OS);
-      } else if (const auto *NNSL = State.getNode<NestedNameSpecifierLoc>()) {
-        dumpNode(Ctx, DynTypedNode::create(*NNSL), OS);
-      } else if (const auto *CtorInit = State.getNode<CXXCtorInitializer>()) {
-        dumpNode(Ctx, DynTypedNode::create(*CtorInit), OS);
-      } else if (const auto *TAL = State.getNode<TemplateArgumentLoc>()) {
-        dumpNode(Ctx, DynTypedNode::create(*TAL), OS);
-      } else if (const auto *At = State.getNode<Attr>()) {
-        dumpNode(Ctx, DynTypedNode::create(*At), OS);
-      }
+      std::visit(llvm::makeVisitor([&](std::monostate) {},
+                                   [&](const DynTypedNode *Node) {
+                                     dumpNode(Ctx, *Node, OS);
+                                   },
+                                   [&](const auto *Node) {
+                                     dumpNode(Ctx, DynTypedNode::create(*Node),
+                                              OS);
+                                   }),
+                 State.Node);
     }
 
   public:
     TraceReporter(const MatchASTVisitor &MV) : MV(MV) {}
     void print(raw_ostream &OS) const override {
       const CurMatchData &State = MV.CurMatchState;
-      const MatchCallback *CB = State.getCallback();
+      const MatchCallback *CB = State.Callback;
       if (!CB) {
         OS << "ASTMatcher: Not currently matching\n";
         return;
       }
 
       assert(MV.ActiveASTContext &&
              "ActiveASTContext should be set if there is a matched callback");
 
       ASTContext &Ctx = MV.getASTContext();
 
-      if (const BoundNodes *Nodes = State.getBoundNodes()) {
+      if (const BoundNodes *Nodes = State.BNodes) {
         OS << "ASTMatcher: Processing '" << CB->getID() << "' against:\n\t";
         dumpNodeFromState(Ctx, State, OS);
         const BoundNodes::IDToNodeMap &Map = Nodes->getMap();
         if (Map.empty()) {
           OS << "\nNo bound nodes\n";
           return;
         }
         OS << "\n--- Bound Nodes Begin ---\n";
void matchDispatch(const CXXCtorInitializer *Node) {
     matchWithoutFilter(*Node, Matchers->CtorInit);
   }
   void matchDispatch(const TemplateArgumentLoc *Node) {
     matchWithoutFilter(*Node, Matchers->TemplateArgumentLoc);
   }
   void matchDispatch(const Attr *Node) {
     matchWithoutFilter(*Node, Matchers->Attr);
   }
+  void matchDispatch(const ConceptReference *Node) {
+    matchWithoutFilter(*Node, Matchers->ConceptReference);
+  }
   void matchDispatch(const void *) { /* Do nothing. */ }
   /// @}
 
   // Returns whether a direct parent of \p Node matches \p Matcher.
   // Unlike matchesAnyAncestorOf there's no memoization: it doesn't save much.
   bool matchesParentOf(const DynTypedNode &Node, const DynTypedMatcher &Matcher,
                        BoundNodesTreeBuilder *Builder) {
     for (const auto &Parent : ActiveASTContext->getParents(Node)) {
#endif
   }
 
   // Implements a BoundNodesTree::Visitor that calls a MatchCallback with
   // the aggregated bound nodes for each match.
   class MatchVisitor : public BoundNodesTreeBuilder::Visitor {
     struct CurBoundScope {
       CurBoundScope(MatchASTVisitor::CurMatchData &State, const BoundNodes &BN)
           : State(State) {
-        State.SetBoundNodes(BN);
+        assert(State.BNodes == nullptr);
+        State.BNodes = &BN;
       }
 
-      ~CurBoundScope() { State.clearBoundNodes(); }
+      ~CurBoundScope() { State.BNodes = nullptr; }
 
     private:
       MatchASTVisitor::CurMatchData &State;
     };
 
   public:
     MatchVisitor(MatchASTVisitor &MV, ASTContext *Context,
                  MatchFinder::MatchCallback *Callback)
bool MatchASTVisitor::TraverseTemplateArgumentLoc(TemplateArgumentLoc Loc) {
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseTemplateArgumentLoc(Loc);
 }
 
 bool MatchASTVisitor::TraverseAttr(Attr *AttrNode) {
   match(*AttrNode);
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseAttr(AttrNode);
 }
 
+bool MatchASTVisitor::TraverseConceptReference(ConceptReference *CR) {
+  match(*CR);
+  return RecursiveASTVisitor::TraverseConceptReference(CR);
+}
+
 class MatchASTConsumer : public ASTConsumer {
 public:
   MatchASTConsumer(MatchFinder *Finder,
                    MatchFinder::ParsingDoneTestCallback *ParsingDone)
       : Finder(Finder), ParsingDone(ParsingDone) {}
 
 private:
   void HandleTranslationUnit(ASTContext &Context) override {

 }
 
 void MatchFinder::addMatcher(const AttrMatcher &AttrMatch,
                              MatchCallback *Action) {
   Matchers.Attr.emplace_back(AttrMatch, Action);
   Matchers.AllCallbacks.insert(Action);
 }
 
+void MatchFinder::addMatcher(const ConceptReferenceMatcher &AttrMatch,
+                             MatchCallback *Action) {
+  Matchers.ConceptReference.emplace_back(AttrMatch, Action);
+  Matchers.AllCallbacks.insert(Action);
+}
+
 bool MatchFinder::addDynamicMatcher(const internal::DynTypedMatcher &NodeMatch,
                                     MatchCallback *Action) {
   if (NodeMatch.canConvertTo<Decl>()) {
     addMatcher(NodeMatch.convertTo<Decl>(), Action);
     return true;
   } else if (NodeMatch.canConvertTo<QualType>()) {
     addMatcher(NodeMatch.convertTo<QualType>(), Action);
     return true;
if (NodeMatch.canConvertTo<Decl>()) {
     addMatcher(NodeMatch.convertTo<CXXCtorInitializer>(), Action);
     return true;
   } else if (NodeMatch.canConvertTo<TemplateArgumentLoc>()) {
     addMatcher(NodeMatch.convertTo<TemplateArgumentLoc>(), Action);
     return true;
   } else if (NodeMatch.canConvertTo<Attr>()) {
     addMatcher(NodeMatch.convertTo<Attr>(), Action);
     return true;
+  } else if (NodeMatch.canConvertTo<ConceptReference>()) {
+    addMatcher(NodeMatch.convertTo<ConceptReference>(), Action);
+    return true;
   }
   return false;
 }
 
 std::unique_ptr<ASTConsumer> MatchFinder::newASTConsumer() {
   return std::make_unique<internal::MatchASTConsumer>(this, ParsingDone);
 }
 

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 const internal::VariadicAllOfMatcher<TemplateArgumentLoc> templateArgumentLoc;
 const internal::VariadicAllOfMatcher<TemplateName> templateName;
 const internal::VariadicDynCastAllOfMatcher<Decl, NonTypeTemplateParmDecl>
     nonTypeTemplateParmDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTypeParmDecl>
     templateTypeParmDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, TemplateTemplateParmDecl>
     templateTemplateParmDecl;
+const internal::VariadicAllOfMatcher<ConceptReference> conceptReference;
 
 const internal::VariadicAllOfMatcher<LambdaCapture> lambdaCapture;
 const internal::VariadicAllOfMatcher<QualType> qualType;
 const internal::VariadicAllOfMatcher<Type> type;
 const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
 
 const internal::VariadicDynCastAllOfMatcher<TypeLoc, QualifiedTypeLoc>
     qualifiedTypeLoc;

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(classTemplateDecl);
   REGISTER_MATCHER(classTemplatePartialSpecializationDecl);
   REGISTER_MATCHER(classTemplateSpecializationDecl);
   REGISTER_MATCHER(complexType);
   REGISTER_MATCHER(compoundLiteralExpr);
   REGISTER_MATCHER(compoundStmt);
   REGISTER_MATCHER(coawaitExpr);
   REGISTER_MATCHER(conceptDecl);
+  REGISTER_MATCHER(conceptReference);
   REGISTER_MATCHER(conditionalOperator);
   REGISTER_MATCHER(constantArrayType);
   REGISTER_MATCHER(constantExpr);
   REGISTER_MATCHER(containsDeclaration);
   REGISTER_MATCHER(continueStmt);
   REGISTER_MATCHER(convertVectorExpr);
   REGISTER_MATCHER(coreturnStmt);
   REGISTER_MATCHER(coroutineBodyStmt);

clang/unittests/AST/ASTTypeTraitsTest.cpp

 
 TEST(DynTypedNode, AttrSourceRange) {
   RangeVerifier<DynTypedNode> Verifier;
   Verifier.expectRange(1, 31, 1, 31);
   EXPECT_TRUE(Verifier.match("void x(char *y __attribute__((nonnull)) );",
                              ast_matchers::attr()));
 }
 
-// FIXME: add tests for ConceptReference once we add an ASTMatcher.
+TEST(DynTypedNode, ConceptReferenceSourceRange) {
+  RangeVerifier<ConceptReference> Verifier;
+  Verifier.expectRange(2, 10, 2, 15);
+  EXPECT_TRUE(Verifier.match("template <class> concept C = true;\n"
+                             "auto X = C<int>;",
+                             conceptReference()));
+}
 
 TEST(DynTypedNode, DeclDump) {
   DumpVerifier Verifier;
   Verifier.expectSubstring("FunctionDecl");
   EXPECT_TRUE(Verifier.match("void f() {}", functionDecl()));
 }
 
 TEST(DynTypedNode, StmtDump) {
   DumpVerifier Verifier;
   Verifier.expectSubstring("CompoundStmt");
   EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
 }
 
+TEST(DynTypedNode, ConceptReferenceDump) {
+  DumpVerifier Verifier;
+  Verifier.expectSubstring("ConceptReference");
+  EXPECT_TRUE(Verifier.match("template <class> concept C = true;\n"
+                             "auto X = C<int>;",
+                             conceptReference()));
+}
+
 TEST(DynTypedNode, DeclPrint) {
   PrintVerifier Verifier;
   Verifier.expectString("void f() {\n}\n");
   EXPECT_TRUE(Verifier.match("void f() {}", functionDecl()));
 }
 
 TEST(DynTypedNode, StmtPrint) {
   PrintVerifier Verifier;
   Verifier.expectString("{\n}\n");
   EXPECT_TRUE(Verifier.match("void f() {}", stmt()));
 }
 
+TEST(DynTypedNode, ConceptReferencePrint) {
+  PrintVerifier Verifier;
+  Verifier.expectString("C<int>");
+  EXPECT_TRUE(Verifier.match("template <class> concept C = true;\n"
+                             "auto X = C<int>;",
+                             conceptReference()));
+}
+
 TEST(DynTypedNode, QualType) {
   QualType Q;
   DynTypedNode Node = DynTypedNode::create(Q);
   EXPECT_TRUE(Node == Node);
   EXPECT_FALSE(Node < Node);
 }
 
 TEST(DynTypedNode, TypeLoc) {

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 TEST_P(ASTMatchersTest, Match_ConstructorInitializers) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(matches("class C { int i; public: C(int ii) : i(ii) {} };",
                       cxxCtorInitializer(forField(hasName("i")))));
 }
 
+TEST_P(ASTMatchersTest, Match_ConceptReference) {
+  if (!GetParam().isCXX20OrLater()) {
+    return;
+  }
+  std::string Concept = "template <class> concept C = true;\n";
+  EXPECT_TRUE(matches(Concept + "auto X = C<int>;", conceptReference()));
+  EXPECT_TRUE(matches(Concept + "C auto X = 0;", conceptReference()));
+  EXPECT_TRUE(matches(Concept + "template <C X> int i;", conceptReference()));
+  EXPECT_TRUE(matches(Concept + "void foo(C auto X) {}", conceptReference()));
+}
+
 TEST_P(ASTMatchersTest, Matcher_ThisExpr) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(
       matches("struct X { int a; int f () { return a; } };", cxxThisExpr()));
   EXPECT_TRUE(
       notMatches("struct X { int f () { int a; return a; } };", cxxThisExpr()));