Add tests for ASTImporter on newly added functions

Test cover all code path including new visit and import
 functions for concept and requirement declarations and
 expressions.

Author: ganenkokb-yandex

clang/include/clang/ASTMatchers/ASTMatchers.h

@@ -55,6 +55,7 @@
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/LambdaCapture.h"
 #include "clang/AST/NestedNameSpecifier.h"
@@ -1363,6 +1364,26 @@ extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
 extern const internal::VariadicDynCastAllOfMatcher<Decl, ConceptDecl>
     conceptDecl;
 
+/// Matches concept requirement.
+///
+/// Example matches requirement expression
+/// \code
+///   template<typename T>
+///   concept dereferencable = requires(T p) { *p; }
+/// \endcode
+extern const internal::VariadicDynCastAllOfMatcher<Expr, RequiresExpr>
+    requiresExpr;
+
+/// Matches concept requirement body declaration.
+///
+/// Example matches equirement body declaration
+/// \code
+///   template<typename T>
+///   concept dereferencable = requires(T p) { *p; }
+/// \endcode
+extern const internal::VariadicDynCastAllOfMatcher<Decl, RequiresExprBodyDecl>
+    requiresExprBodyDecl;
+
 /// Matches variable declarations.
 ///
 /// Note: this does not match declarations of member variables, which are

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

@@ -15,6 +15,7 @@
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ParentMapContext.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
@@ -826,6 +827,9 @@ const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> cxxMethodDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
     cxxConversionDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, ConceptDecl> conceptDecl;
+const internal::VariadicDynCastAllOfMatcher<Expr, RequiresExpr> requiresExpr;
+const internal::VariadicDynCastAllOfMatcher<Decl, RequiresExprBodyDecl>
+    requiresExprBodyDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, IndirectFieldDecl>

clang/unittests/AST/ASTImporterTest.cpp

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Testing/CommandLineArgs.h"
@@ -3217,6 +3218,102 @@ TEST_P(ImportExpr, UnresolvedMemberExpr) {
                  compoundStmt(has(callExpr(has(unresolvedMemberExpr())))))))));
 }
 
+TEST_P(ImportExpr, ConceptNoRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+    template<typename T>
+    struct is_int { static const bool value = false; };
+    template<> struct is_int<int> { static const bool value = true; };
+    template<typename T>
+    concept declToImport = is_int<T>::value;
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(unless(has(requiresExpr()))));
+}
+
+TEST_P(ImportExpr, ConceptSimpleRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+  template <class T1, class T2>
+  concept declToImport = requires(T1 i, T2 j) {
+    i + j;
+  };
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(has(requiresExpr(has(requiresExprBodyDecl())))));
+}
+
+TEST_P(ImportExpr, ConceptCompoundNonTypeRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+  template <class T1, class T2>
+  concept declToImport = requires(T1 i, T2 j) {
+    {i + j};
+  };
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(has(requiresExpr(has(requiresExprBodyDecl())))));
+}
+
+TEST_P(ImportExpr, ConceptCompoundTypeRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+    template<typename T>
+    struct is_int { static const bool value = false; };
+    template<> struct is_int<int> { static const bool value = true; };
+
+    template<typename T>
+    concept type_is_int = is_int<T>::value;
+
+    template<typename T>
+    concept declToImport = requires(T x) {
+      {x * 1} -> type_is_int;
+    };
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(has(requiresExpr(has(requiresExprBodyDecl())))));
+}
+
+TEST_P(ImportExpr, ConceptTypeRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+  template <class T>
+  concept declToImport = requires {
+    typename T::value;
+  };
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(has(requiresExpr(has(requiresExprBodyDecl())))));
+}
+
+TEST_P(ImportExpr, ConceptNestedRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+    template<typename T>
+    struct is_int { static const bool value = false; };
+    template<> struct is_int<int> { static const bool value = true; };
+
+    template<typename T>
+    concept declToImport = requires(T x) {
+      requires is_int<T>::value;
+    };
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(has(requiresExpr(has(requiresExprBodyDecl())))));
+}
+
+TEST_P(ImportExpr, ConceptNestedNonInstantiationDependentRequirement) {
+  MatchVerifier<Decl> Verifier;
+  const char *Code = R"(
+    template<typename T>
+    concept declToImport = requires {
+      requires sizeof(long) == sizeof(int);
+    };
+  )";
+  testImport(Code, Lang_CXX20, "", Lang_CXX20, Verifier,
+             conceptDecl(has(requiresExpr(has(requiresExprBodyDecl())))));
+}
+
 class ImportImplicitMethods : public ASTImporterOptionSpecificTestBase {
 public:
   static constexpr auto DefaultCode = R"(