struct CanonicalRedeclChain : ASTImporterOptionSpecificTestBase {};
TEST_P(CanonicalRedeclChain, ShouldBeConsequentWithMatchers) {
- Decl *FromTU = getTuDecl("void f();", Lang_CXX);
+ Decl *FromTU = getTuDecl("void f();", Lang_CXX03);
auto Pattern = functionDecl(hasName("f"));
auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
}
TEST_P(CanonicalRedeclChain, ShouldBeConsequentWithMatchers2) {
- Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX);
+ Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX03);
auto Pattern = functionDecl(hasName("f"));
auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
auto *D2 = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
}
TEST_P(CanonicalRedeclChain, ShouldBeSameForAllDeclInTheChain) {
- Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX);
+ Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX03);
auto Pattern = functionDecl(hasName("f"));
auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
auto *D2 = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
TEST_P(RedirectingImporterTest, InterceptImport) {
Decl *From, *To;
std::tie(From, To) =
- getImportedDecl("class shouldNotBeImported {};", Lang_CXX,
- "class realDecl {};", Lang_CXX, "shouldNotBeImported");
+ getImportedDecl("class shouldNotBeImported {};", Lang_CXX03,
+ "class realDecl {};", Lang_CXX03, "shouldNotBeImported");
auto *Imported = cast<CXXRecordDecl>(To);
EXPECT_EQ(Imported->getQualifiedNameAsString(), "realDecl");
std::tie(From, To) =
getImportedDecl("class shouldNotBeImported {};"
"class F { shouldNotBeImported f; };",
- Lang_CXX, "class realDecl {};", Lang_CXX, "F");
+ Lang_CXX03, "class realDecl {};", Lang_CXX03, "F");
// Make sure our ASTImporter prevented the importing of the decl.
auto *ToTU = To->getTranslationUnitDecl();
Decl *FromTU;
FunctionDecl *D0, *D1, *D2;
ImportPath() {
- FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX);
+ FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX03);
auto Pattern = functionDecl(hasName("f"));
D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
D2 = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
TEST_P(ImportExpr, ImportStringLiteral) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { (void)\"foo\"; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- stringLiteral(hasType(asString("const char [4]"))))));
- testImport(
- "void declToImport() { (void)L\"foo\"; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- stringLiteral(hasType(asString("const wchar_t [4]"))))));
- testImport(
- "void declToImport() { (void) \"foo\" \"bar\"; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- stringLiteral(hasType(asString("const char [7]"))))));
+ testImport("void declToImport() { (void)\"foo\"; }", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(
+ stringLiteral(hasType(asString("const char [4]"))))));
+ testImport("void declToImport() { (void)L\"foo\"; }", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(
+ stringLiteral(hasType(asString("const wchar_t [4]"))))));
+ testImport("void declToImport() { (void) \"foo\" \"bar\"; }", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(
+ stringLiteral(hasType(asString("const char [7]"))))));
}
TEST_P(ImportExpr, ImportChooseExpr) {
// This case tests C code that is not condition-dependent and has a true
// condition.
- testImport(
- "void declToImport() { (void)__builtin_choose_expr(1, 2, 3); }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(hasDescendant(chooseExpr())));
+ testImport("void declToImport() { (void)__builtin_choose_expr(1, 2, 3); }",
+ Lang_C99, "", Lang_C99, Verifier,
+ functionDecl(hasDescendant(chooseExpr())));
}
TEST_P(ImportExpr, ImportGNUNullExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { (void)__null; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(gnuNullExpr(hasType(isInteger())))));
+ testImport("void declToImport() { (void)__null; }", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(gnuNullExpr(hasType(isInteger())))));
}
TEST_P(ImportExpr, ImportCXXNullPtrLiteralExpr) {
TEST_P(ImportExpr, ImportFloatinglLiteralExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { (void)1.0; }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(hasDescendant(
- floatLiteral(equals(1.0), hasType(asString("double"))))));
- testImport(
- "void declToImport() { (void)1.0e-5f; }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(hasDescendant(
- floatLiteral(equals(1.0e-5f), hasType(asString("float"))))));
+ testImport("void declToImport() { (void)1.0; }", Lang_C99, "", Lang_C99,
+ Verifier,
+ functionDecl(hasDescendant(
+ floatLiteral(equals(1.0), hasType(asString("double"))))));
+ testImport("void declToImport() { (void)1.0e-5f; }", Lang_C99, "", Lang_C99,
+ Verifier,
+ functionDecl(hasDescendant(
+ floatLiteral(equals(1.0e-5f), hasType(asString("float"))))));
}
TEST_P(ImportFixedPointExpr, ImportFixedPointerLiteralExpr) {
MatchVerifier<Decl> Verifier;
- testImport("void declToImport() { (void)1.0k; }", Lang_C, "", Lang_C,
+ testImport("void declToImport() { (void)1.0k; }", Lang_C99, "", Lang_C99,
Verifier, functionDecl(hasDescendant(fixedPointLiteral())));
- testImport("void declToImport() { (void)0.75r; }", Lang_C, "", Lang_C,
+ testImport("void declToImport() { (void)0.75r; }", Lang_C99, "", Lang_C99,
Verifier, functionDecl(hasDescendant(fixedPointLiteral())));
}
TEST_P(ImportExpr, ImportCompoundLiteralExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() {"
- " struct s { int x; long y; unsigned z; }; "
- " (void)(struct s){ 42, 0L, 1U }; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- compoundLiteralExpr(
- hasType(asString("struct s")),
- has(initListExpr(
- hasType(asString("struct s")),
- has(integerLiteral(
- equals(42), hasType(asString("int")))),
- has(integerLiteral(
- equals(0), hasType(asString("long")))),
- has(integerLiteral(
- equals(1), hasType(asString("unsigned int"))))))))));
+ testImport("void declToImport() {"
+ " struct s { int x; long y; unsigned z; }; "
+ " (void)(struct s){ 42, 0L, 1U }; }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(compoundLiteralExpr(
+ hasType(asString("struct s")),
+ has(initListExpr(
+ hasType(asString("struct s")),
+ has(integerLiteral(equals(42), hasType(asString("int")))),
+ has(integerLiteral(equals(0), hasType(asString("long")))),
+ has(integerLiteral(
+ equals(1), hasType(asString("unsigned int"))))))))));
}
TEST_P(ImportExpr, ImportCXXThisExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "class declToImport { void f() { (void)this; } };",
- Lang_CXX, "", Lang_CXX, Verifier,
- cxxRecordDecl(
- hasMethod(
- hasDescendant(
- cxxThisExpr(
- hasType(
- asString("class declToImport *")))))));
+ testImport("class declToImport { void f() { (void)this; } };", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ cxxRecordDecl(hasMethod(hasDescendant(
+ cxxThisExpr(hasType(asString("class declToImport *")))))));
}
TEST_P(ImportExpr, ImportAtomicExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(hasDescendant(
- atomicExpr(
- has(ignoringParenImpCasts(
- declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
- hasType(asString("int *"))))),
- has(integerLiteral(equals(1), hasType(asString("int"))))))));
+ testImport("void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
+ Lang_C99, "", Lang_C99, Verifier,
+ functionDecl(hasDescendant(atomicExpr(
+ has(ignoringParenImpCasts(
+ declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
+ hasType(asString("int *"))))),
+ has(integerLiteral(equals(1), hasType(asString("int"))))))));
}
TEST_P(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { loop: goto loop; (void)&&loop; }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(
- hasDescendant(
- labelStmt(hasDeclaration(labelDecl(hasName("loop"))))),
- hasDescendant(
- addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))));
+ testImport("void declToImport() { loop: goto loop; (void)&&loop; }", Lang_C99,
+ "", Lang_C99, Verifier,
+ functionDecl(hasDescendant(labelStmt(
+ hasDeclaration(labelDecl(hasName("loop"))))),
+ hasDescendant(addrLabelExpr(
+ hasDeclaration(labelDecl(hasName("loop")))))));
}
AST_MATCHER_P(TemplateDecl, hasTemplateDecl,
"template<typename T> class dummy { void f() { dummy X(*this); } };"
"typedef dummy<int> declToImport;"
"template class dummy<int>;",
- Lang_CXX, "", Lang_CXX, Verifier,
+ Lang_CXX03, "", Lang_CXX03, Verifier,
typedefDecl(hasType(templateSpecializationType(
hasDeclaration(classTemplateSpecializationDecl(hasSpecializedTemplate(
classTemplateDecl(hasTemplateDecl(cxxRecordDecl(hasMethod(allOf(
TEST_P(ImportExpr, ImportSwitch) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { int b; switch (b) { case 1: break; } }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(hasDescendant(
- switchStmt(has(compoundStmt(has(caseStmt())))))));
+ testImport("void declToImport() { int b; switch (b) { case 1: break; } }",
+ Lang_C99, "", Lang_C99, Verifier,
+ functionDecl(hasDescendant(
+ switchStmt(has(compoundStmt(has(caseStmt())))))));
}
TEST_P(ImportExpr, ImportStmtExpr) {
MatchVerifier<Decl> Verifier;
testImport(
"void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
- Lang_C, "", Lang_C, Verifier,
+ Lang_C99, "", Lang_C99, Verifier,
traverse(ast_type_traits::TK_AsIs,
functionDecl(hasDescendant(varDecl(
hasName("C"), hasType(asString("int")),
TEST_P(ImportExpr, ImportConditionalOperator) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport() { (void)(true ? 1 : -5); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- conditionalOperator(
- hasCondition(cxxBoolLiteral(equals(true))),
- hasTrueExpression(integerLiteral(equals(1))),
- hasFalseExpression(
- unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))))
- )));
+ testImport("void declToImport() { (void)(true ? 1 : -5); }", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(conditionalOperator(
+ hasCondition(cxxBoolLiteral(equals(true))),
+ hasTrueExpression(integerLiteral(equals(1))),
+ hasFalseExpression(unaryOperator(
+ hasUnaryOperand(integerLiteral(equals(5)))))))));
}
TEST_P(ImportExpr, ImportBinaryConditionalOperator) {
MatchVerifier<Decl> Verifier;
testImport(
- "void declToImport() { (void)(1 ?: -5); }", Lang_CXX, "", Lang_CXX,
+ "void declToImport() { (void)(1 ?: -5); }", Lang_CXX03, "", Lang_CXX03,
Verifier,
traverse(ast_type_traits::TK_AsIs,
functionDecl(hasDescendant(binaryConditionalOperator(
" struct point { double x; double y; };"
" struct point ptarray[10] = "
"{ [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
- Lang_C, "", Lang_C, Verifier,
- functionDecl(hasDescendant(
- initListExpr(
- has(designatedInitExpr(
- designatorCountIs(2),
- hasDescendant(floatLiteral(equals(1.0))),
- hasDescendant(integerLiteral(equals(2))))),
- has(designatedInitExpr(
- designatorCountIs(2),
- hasDescendant(floatLiteral(equals(2.0))),
- hasDescendant(integerLiteral(equals(2))))),
- has(designatedInitExpr(
- designatorCountIs(2),
- hasDescendant(floatLiteral(equals(1.0))),
- hasDescendant(integerLiteral(equals(0)))))))));
+ Lang_C99, "", Lang_C99, Verifier,
+ functionDecl(hasDescendant(initListExpr(
+ has(designatedInitExpr(designatorCountIs(2),
+ hasDescendant(floatLiteral(equals(1.0))),
+ hasDescendant(integerLiteral(equals(2))))),
+ has(designatedInitExpr(designatorCountIs(2),
+ hasDescendant(floatLiteral(equals(2.0))),
+ hasDescendant(integerLiteral(equals(2))))),
+ has(designatedInitExpr(designatorCountIs(2),
+ hasDescendant(floatLiteral(equals(1.0))),
+ hasDescendant(integerLiteral(equals(0)))))))));
}
TEST_P(ImportExpr, ImportPredefinedExpr) {
MatchVerifier<Decl> Verifier;
// __func__ expands as StringLiteral("declToImport")
- testImport(
- "void declToImport() { (void)__func__; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- predefinedExpr(
- hasType(
- asString("const char [13]")),
- has(stringLiteral(hasType(
- asString("const char [13]"))))))));
+ testImport("void declToImport() { (void)__func__; }", Lang_CXX03, "",
+ Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(predefinedExpr(
+ hasType(asString("const char [13]")),
+ has(stringLiteral(hasType(asString("const char [13]"))))))));
}
TEST_P(ImportExpr, ImportInitListExpr) {
" struct point { double x; double y; };"
" point ptarray[10] = { [2].y = 1.0, [2].x = 2.0,"
" [0].x = 1.0 }; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- initListExpr(
- has(
- cxxConstructExpr(
- requiresZeroInitialization())),
- has(
- initListExpr(
- hasType(asString("struct point")),
- has(floatLiteral(equals(1.0))),
- has(implicitValueInitExpr(
- hasType(asString("double")))))),
- has(
- initListExpr(
- hasType(asString("struct point")),
- has(floatLiteral(equals(2.0))),
- has(floatLiteral(equals(1.0)))))))));
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(initListExpr(
+ has(cxxConstructExpr(requiresZeroInitialization())),
+ has(initListExpr(
+ hasType(asString("struct point")), has(floatLiteral(equals(1.0))),
+ has(implicitValueInitExpr(hasType(asString("double")))))),
+ has(initListExpr(hasType(asString("struct point")),
+ has(floatLiteral(equals(2.0))),
+ has(floatLiteral(equals(1.0)))))))));
}
TEST_P(ImportExpr, ImportVAArgExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "void declToImport(__builtin_va_list list, ...) {"
- " (void)__builtin_va_arg(list, int); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- cStyleCastExpr(hasSourceExpression(vaArgExpr())))));
+ testImport("void declToImport(__builtin_va_list list, ...) {"
+ " (void)__builtin_va_arg(list, int); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(
+ cStyleCastExpr(hasSourceExpression(vaArgExpr())))));
}
TEST_P(ImportExpr, CXXTemporaryObjectExpr) {
testImport(
"struct C {};"
"void declToImport() { C c = C(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
+ Lang_CXX03, "", Lang_CXX03, Verifier,
traverse(ast_type_traits::TK_AsIs,
functionDecl(hasDescendant(exprWithCleanups(has(cxxConstructExpr(
has(materializeTemporaryExpr(has(implicitCastExpr(
TEST_P(ImportDecl, ImportFunctionTemplateDecl) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template <typename T> void declToImport() { };",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl());
+ testImport("template <typename T> void declToImport() { };", Lang_CXX03, "",
+ Lang_CXX03, Verifier, functionTemplateDecl());
}
TEST_P(ImportExpr, ImportCXXDependentScopeMemberExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template <typename T> struct C { T t; };"
- "template <typename T> void declToImport() {"
- " C<T> d;"
- " (void)d.t;"
- "}"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl(hasDescendant(
- cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
- testImport(
- "template <typename T> struct C { T t; };"
- "template <typename T> void declToImport() {"
- " C<T> d;"
- " (void)(&d)->t;"
- "}"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl(hasDescendant(
- cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
+ testImport("template <typename T> struct C { T t; };"
+ "template <typename T> void declToImport() {"
+ " C<T> d;"
+ " (void)d.t;"
+ "}"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionTemplateDecl(hasDescendant(
+ cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
+ testImport("template <typename T> struct C { T t; };"
+ "template <typename T> void declToImport() {"
+ " C<T> d;"
+ " (void)(&d)->t;"
+ "}"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionTemplateDecl(hasDescendant(
+ cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
}
TEST_P(ImportType, ImportTypeAliasTemplate) {
TEST_P(ImportType, ImportDependentTemplateSpecialization) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template<typename T>"
- "struct A;"
- "template<typename T>"
- "struct declToImport {"
- " typename A<T>::template B<T> a;"
- "};",
- Lang_CXX, "", Lang_CXX, Verifier,
- classTemplateDecl(has(cxxRecordDecl(has(
- fieldDecl(hasType(dependentTemplateSpecializationType())))))));
+ testImport("template<typename T>"
+ "struct A;"
+ "template<typename T>"
+ "struct declToImport {"
+ " typename A<T>::template B<T> a;"
+ "};",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ classTemplateDecl(has(cxxRecordDecl(has(
+ fieldDecl(hasType(dependentTemplateSpecializationType())))))));
}
const internal::VariadicDynCastAllOfMatcher<Stmt, SizeOfPackExpr>
"void declToImport() { "
" (void)__builtin_types_compatible_p(int, int);"
"}",
- Lang_C, "", Lang_C, Verifier,
+ Lang_C99, "", Lang_C99, Verifier,
functionDecl(hasDescendant(typeTraitExpr(hasType(asString("int"))))));
}
" struct data_t d;"
" return 0;"
"}",
- Lang_C, "", Lang_C, Verifier,
+ Lang_C99, "", Lang_C99, Verifier,
functionDecl(hasBody(compoundStmt(
has(declStmt(hasSingleDecl(varDecl(hasName("d")))))))));
}
" struct data_t d;"
" return 0;"
"}",
- Lang_C, "input.c");
+ Lang_C99, "input.c");
auto *FromVar =
FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("d")));
ASSERT_TRUE(FromVar);
auto ToType =
- ImportType(FromVar->getType().getCanonicalType(), FromVar, Lang_C);
+ ImportType(FromVar->getType().getCanonicalType(), FromVar, Lang_C99);
EXPECT_FALSE(ToType.isNull());
}
// This construct is not supported by ASTImporter.
Decl *FromTU = getTuDecl(
"int declToImport(struct data_t{int a;int b;} ***d){ return 0; }",
- Lang_C, "input.c");
+ Lang_C99, "input.c");
auto *From = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("declToImport")));
ASSERT_TRUE(From);
- auto *To = Import(From, Lang_C);
+ auto *To = Import(From, Lang_C99);
EXPECT_EQ(To, nullptr);
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordDeclInFuncFromMacro) {
- Decl *FromTU = getTuDecl(
- "#define NONAME_SIZEOF(type) sizeof(struct{type *dummy;}) \n"
- "int declToImport(){ return NONAME_SIZEOF(int); }",
- Lang_C, "input.c");
+ Decl *FromTU =
+ getTuDecl("#define NONAME_SIZEOF(type) sizeof(struct{type *dummy;}) \n"
+ "int declToImport(){ return NONAME_SIZEOF(int); }",
+ Lang_C99, "input.c");
auto *From = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("declToImport")));
ASSERT_TRUE(From);
- auto *To = Import(From, Lang_C);
+ auto *To = Import(From, Lang_C99);
ASSERT_TRUE(To);
EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
To, functionDecl(hasName("declToImport"),
TEST_P(ASTImporterOptionSpecificTestBase,
ImportRecordDeclInFuncParamsFromMacro) {
// This construct is not supported by ASTImporter.
- Decl *FromTU = getTuDecl(
- "#define PAIR_STRUCT(type) struct data_t{type a;type b;} \n"
- "int declToImport(PAIR_STRUCT(int) ***d){ return 0; }",
- Lang_C, "input.c");
+ Decl *FromTU =
+ getTuDecl("#define PAIR_STRUCT(type) struct data_t{type a;type b;} \n"
+ "int declToImport(PAIR_STRUCT(int) ***d){ return 0; }",
+ Lang_C99, "input.c");
auto *From = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("declToImport")));
ASSERT_TRUE(From);
- auto *To = Import(From, Lang_C);
+ auto *To = Import(From, Lang_C99);
EXPECT_EQ(To, nullptr);
}
" T t;"
" p->T::~T();"
"}",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(
- callExpr(has(cxxPseudoDestructorExpr())))));
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(callExpr(has(cxxPseudoDestructorExpr())))));
}
TEST_P(ImportDecl, ImportUsingDecl) {
MatchVerifier<Decl> Verifier;
- testImport(
- "namespace foo { int bar; }"
- "void declToImport() { using foo::bar; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionDecl(hasDescendant(usingDecl())));
+ testImport("namespace foo { int bar; }"
+ "void declToImport() { using foo::bar; }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionDecl(hasDescendant(usingDecl())));
}
/// \brief Matches shadow declarations introduced into a scope by a
TEST_P(ImportDecl, ImportUsingShadowDecl) {
MatchVerifier<Decl> Verifier;
- testImport(
- "namespace foo { int bar; }"
- "namespace declToImport { using foo::bar; }",
- Lang_CXX, "", Lang_CXX, Verifier,
- namespaceDecl(has(usingShadowDecl())));
+ testImport("namespace foo { int bar; }"
+ "namespace declToImport { using foo::bar; }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ namespaceDecl(has(usingShadowDecl())));
}
TEST_P(ImportExpr, ImportUnresolvedLookupExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template<typename T> int foo();"
- "template <typename T> void declToImport() {"
- " (void)::foo<T>;"
- " (void)::template foo<T>;"
- "}"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl(hasDescendant(unresolvedLookupExpr())));
+ testImport("template<typename T> int foo();"
+ "template <typename T> void declToImport() {"
+ " (void)::foo<T>;"
+ " (void)::template foo<T>;"
+ "}"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionTemplateDecl(hasDescendant(unresolvedLookupExpr())));
}
TEST_P(ImportExpr, ImportCXXUnresolvedConstructExpr) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template <typename T> struct C { T t; };"
- "template <typename T> void declToImport() {"
- " C<T> d;"
- " d.t = T();"
- "}"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl(hasDescendant(
- binaryOperator(has(cxxUnresolvedConstructExpr())))));
- testImport(
- "template <typename T> struct C { T t; };"
- "template <typename T> void declToImport() {"
- " C<T> d;"
- " (&d)->t = T();"
- "}"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl(hasDescendant(
- binaryOperator(has(cxxUnresolvedConstructExpr())))));
+ testImport("template <typename T> struct C { T t; };"
+ "template <typename T> void declToImport() {"
+ " C<T> d;"
+ " d.t = T();"
+ "}"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionTemplateDecl(hasDescendant(
+ binaryOperator(has(cxxUnresolvedConstructExpr())))));
+ testImport("template <typename T> struct C { T t; };"
+ "template <typename T> void declToImport() {"
+ " C<T> d;"
+ " (&d)->t = T();"
+ "}"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionTemplateDecl(hasDescendant(
+ binaryOperator(has(cxxUnresolvedConstructExpr())))));
}
/// Check that function "declToImport()" (which is the templated function
/// Same for class template declarations.
TEST_P(ImportDecl, ImportTemplatedDeclForTemplate) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template <typename T> void declToImport() { T a = 1; }"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- functionTemplateDecl(hasAncestor(translationUnitDecl(
- unless(has(functionDecl(hasName("declToImport"))))))));
- testImport(
- "template <typename T> struct declToImport { T t; };"
- "void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX, Verifier,
- classTemplateDecl(hasAncestor(translationUnitDecl(
- unless(has(cxxRecordDecl(hasName("declToImport"))))))));
+ testImport("template <typename T> void declToImport() { T a = 1; }"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ functionTemplateDecl(hasAncestor(translationUnitDecl(
+ unless(has(functionDecl(hasName("declToImport"))))))));
+ testImport("template <typename T> struct declToImport { T t; };"
+ "void instantiate() { declToImport<int>(); }",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ classTemplateDecl(hasAncestor(translationUnitDecl(
+ unless(has(cxxRecordDecl(hasName("declToImport"))))))));
}
TEST_P(ImportDecl, ImportClassTemplatePartialSpecialization) {
template <typename T0> struct X<T0 *> {};
};
)s";
- testImport(Code, Lang_CXX, "", Lang_CXX, Verifier,
+ testImport(Code, Lang_CXX03, "", Lang_CXX03, Verifier,
recordDecl(has(classTemplateDecl()),
has(classTemplateSpecializationDecl())));
}
"class declToImport {"
" void f() { *this = declToImport(); }"
"};",
- Lang_CXX, "", Lang_CXX, Verifier,
- cxxRecordDecl(has(cxxMethodDecl(hasDescendant(
- cxxOperatorCallExpr())))));
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ cxxRecordDecl(has(cxxMethodDecl(hasDescendant(cxxOperatorCallExpr())))));
}
TEST_P(ImportExpr, DependentSizedArrayType) {
MatchVerifier<Decl> Verifier;
- testImport(
- "template<typename T, int Size> class declToImport {"
- " T data[Size];"
- "};",
- Lang_CXX, "", Lang_CXX, Verifier,
- classTemplateDecl(has(cxxRecordDecl(
- has(fieldDecl(hasType(dependentSizedArrayType())))))));
+ testImport("template<typename T, int Size> class declToImport {"
+ " T data[Size];"
+ "};",
+ Lang_CXX03, "", Lang_CXX03, Verifier,
+ classTemplateDecl(has(cxxRecordDecl(
+ has(fieldDecl(hasType(dependentSizedArrayType())))))));
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportBeginLocOfDeclRefExpr) {
- Decl *FromTU = getTuDecl(
- "class A { public: static int X; }; void f() { (void)A::X; }", Lang_CXX);
+ Decl *FromTU =
+ getTuDecl("class A { public: static int X; }; void f() { (void)A::X; }",
+ Lang_CXX03);
auto From = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
ASSERT_TRUE(From);
->getSubExpr()
->getBeginLoc()
.isValid());
- FunctionDecl *To = Import(From, Lang_CXX);
+ FunctionDecl *To = Import(From, Lang_CXX03);
ASSERT_TRUE(To);
ASSERT_TRUE(
cast<CStyleCastExpr>(cast<CompoundStmt>(To->getBody())->body_front())
TEST_P(ASTImporterOptionSpecificTestBase,
ImportOfTemplatedDeclOfClassTemplateDecl) {
- Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
+ Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX03);
auto From =
FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
ASSERT_TRUE(From);
- auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX));
+ auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX03));
ASSERT_TRUE(To);
Decl *ToTemplated = To->getTemplatedDecl();
- Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX);
+ Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX03);
EXPECT_TRUE(ToTemplated1);
EXPECT_EQ(ToTemplated1, ToTemplated);
}
TEST_P(ASTImporterOptionSpecificTestBase,
ImportOfTemplatedDeclOfFunctionTemplateDecl) {
- Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX);
+ Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX03);
auto From = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU, functionTemplateDecl());
ASSERT_TRUE(From);
- auto To = cast<FunctionTemplateDecl>(Import(From, Lang_CXX));
+ auto To = cast<FunctionTemplateDecl>(Import(From, Lang_CXX03));
ASSERT_TRUE(To);
Decl *ToTemplated = To->getTemplatedDecl();
- Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX);
+ Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX03);
EXPECT_TRUE(ToTemplated1);
EXPECT_EQ(ToTemplated1, ToTemplated);
}
TEST_P(ASTImporterOptionSpecificTestBase,
ImportOfTemplatedDeclShouldImportTheClassTemplateDecl) {
- Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
+ Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX03);
auto FromFT =
FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
ASSERT_TRUE(FromFT);
auto ToTemplated =
- cast<CXXRecordDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX));
+ cast<CXXRecordDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX03));
EXPECT_TRUE(ToTemplated);
auto ToTU = ToTemplated->getTranslationUnitDecl();
auto ToFT =
TEST_P(ASTImporterOptionSpecificTestBase,
ImportOfTemplatedDeclShouldImportTheFunctionTemplateDecl) {
- Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX);
+ Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX03);
auto FromFT = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU, functionTemplateDecl());
ASSERT_TRUE(FromFT);
auto ToTemplated =
- cast<FunctionDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX));
+ cast<FunctionDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX03));
EXPECT_TRUE(ToTemplated);
auto ToTU = ToTemplated->getTranslationUnitDecl();
auto ToFT = FirstDeclMatcher<FunctionTemplateDecl>().match(
template<class X> struct S3{};
}
)";
- Decl *FromTU = getTuDecl(Code, Lang_CXX);
+ Decl *FromTU = getTuDecl(Code, Lang_CXX03);
auto FromNs =
FirstDeclMatcher<NamespaceDecl>().match(FromTU, namespaceDecl());
- auto ToNs = cast<NamespaceDecl>(Import(FromNs, Lang_CXX));
+ auto ToNs = cast<NamespaceDecl>(Import(FromNs, Lang_CXX03));
ASSERT_TRUE(ToNs);
auto From =
FirstDeclMatcher<ClassTemplateDecl>().match(FromTU,
ASSERT_TRUE(To);
auto ToTemplated = To->getTemplatedDecl();
auto ToTemplated1 =
- cast<CXXRecordDecl>(Import(From->getTemplatedDecl(), Lang_CXX));
+ cast<CXXRecordDecl>(Import(From->getTemplatedDecl(), Lang_CXX03));
EXPECT_TRUE(ToTemplated1);
ASSERT_EQ(ToTemplated1, ToTemplated);
}
// gets it right.
Decl *From, *To;
std::tie(From, To) = getImportedDecl(
- "void declToImport() { (void)__builtin_choose_expr(1, 0, 1); }",
- Lang_C, "", Lang_C);
+ "void declToImport() { (void)__builtin_choose_expr(1, 0, 1); }", Lang_C99,
+ "", Lang_C99);
auto ToResults = match(chooseExpr().bind("choose"), To->getASTContext());
auto FromResults = match(chooseExpr().bind("choose"), From->getASTContext());
}
};
)",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
MatchVerifier<Decl> Verifier;
auto Matcher = functionDecl(hasName("declToImport"),
std::tie(From, To) =
getImportedDecl("template <typename T> void declToImport() { T a = 1; }"
"void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
auto Check = [](Decl *D) -> bool {
auto TU = D->getTranslationUnitDecl();
std::tie(From, To) =
getImportedDecl("template <typename T> struct declToImport { T t; };"
"void instantiate() { declToImport<int>(); }",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
auto Check = [](Decl *D) -> bool {
auto TU = D->getTranslationUnitDecl();
class Base {};
class declToImport : public Base<declToImport> {};
)",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
// Check that the ClassTemplateSpecializationDecl is NOT the child of the TU.
auto Pattern =
template class X<int>;
}
)",
- Lang_CXX, "", Lang_CXX, "NS");
+ Lang_CXX03, "", Lang_CXX03, "NS");
// Check that the ClassTemplateSpecializationDecl is NOT the child of the
// ClassTemplateDecl.
struct declToImport {
};
)",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
MatchVerifier<Decl> Verifier;
// Match the implicit Decl.
struct declToImport {
};
)",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
MatchVerifier<Decl> Verifier;
// Match the implicit Decl.
class Base {};
class declToImport : public Base<declToImport> {};
)",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
auto hasImplicitClass = has(cxxRecordDecl());
auto Pattern = translationUnitDecl(has(classTemplateDecl(
TEST_P(ASTImporterOptionSpecificTestBase, IDNSOrdinary) {
Decl *From, *To;
std::tie(From, To) =
- getImportedDecl("void declToImport() {}", Lang_CXX, "", Lang_CXX);
+ getImportedDecl("void declToImport() {}", Lang_CXX03, "", Lang_CXX03);
MatchVerifier<Decl> Verifier;
auto Matcher = functionDecl();
struct X {};
void operator<<(int, X);
)",
- Lang_CXX);
+ Lang_CXX03);
Decl *From = LastDeclMatcher<Decl>{}.match(FromTU, functionDecl());
- const Decl *To = Import(From, Lang_CXX);
+ const Decl *To = Import(From, Lang_CXX03);
EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
}
class Base { int a; };
class declToImport : Base<declToImport> {};
)",
- Lang_CXX, "", Lang_CXX);
+ Lang_CXX03, "", Lang_CXX03);
auto Pattern = translationUnitDecl(has(classTemplateDecl(
hasName("Base"),
template <typename T>
struct B;
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU, classTemplateDecl(hasName("B")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
{
void f();
};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
FunctionDecl *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
auto *FromCTD = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU, classTemplateDecl(hasName("B")));
- auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX));
+ auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX03));
EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
}
}
template <typename T>
struct B;
)",
- Lang_CXX);
+ Lang_CXX03);
ASSERT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
[](const ClassTemplateDecl *T) {
return T->isThisDeclarationADefinition();
void f();
};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
ClassTemplateDecl *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU, classTemplateDecl(hasName("B")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
// We should have only one definition.
EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
struct B;
)",
- Lang_CXX);
+ Lang_CXX03);
ASSERT_EQ(2u, DeclCounter<CXXRecordDecl>().match(
ToTU, cxxRecordDecl(unless(isImplicit()))));
void f();
};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("B")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
EXPECT_EQ(2u, DeclCounter<CXXRecordDecl>().match(
ToTU, cxxRecordDecl(unless(isImplicit()))));
MFOO(a);
}
)",
- Lang_CXX);
+ Lang_CXX03);
auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
- auto ToD = Import(FromD, Lang_CXX);
+ auto ToD = Import(FromD, Lang_CXX03);
auto ToLHS = LastDeclMatcher<DeclRefExpr>().match(ToD, declRefExpr());
auto FromLHS = LastDeclMatcher<DeclRefExpr>().match(FromTU, declRefExpr());
#define FUNC FUNC_INT
FUNC(int a);
)",
- Lang_CXX);
+ Lang_CXX03);
auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
- auto ToD = Import(FromD, Lang_CXX);
+ auto ToD = Import(FromD, Lang_CXX03);
SourceManager &ToSM = ToAST->getASTContext().getSourceManager();
SourceManager &FromSM = FromD->getASTContext().getSourceManager();
template <>
struct B<int>;
)",
- Lang_CXX);
+ Lang_CXX03);
// We should have only one definition.
ASSERT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
[](const ClassTemplateSpecializationDecl *T) {
template <>
struct B<int> {};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
FromTU, classTemplateSpecializationDecl(hasName("B")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
// We should have only one definition.
EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
struct { int a; int b; } object0 = { 2, 3 };
struct { int x; int y; int z; } object1;
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *Obj0 =
FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("object0")));
FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("object1")));
auto *From1 = getRecordDecl(Obj1);
- auto *To0 = Import(From0, Lang_CXX);
- auto *To1 = Import(From1, Lang_CXX);
+ auto *To0 = Import(From0, Lang_CXX03);
+ auto *To1 = Import(From1, Lang_CXX03);
EXPECT_TRUE(To0);
EXPECT_TRUE(To1);
struct { int b; };
};
)";
- Decl *FromTU0 = getTuDecl(Code, Lang_C, "input0.c");
+ Decl *FromTU0 = getTuDecl(Code, Lang_C99, "input0.c");
- Decl *FromTU1 = getTuDecl(Code, Lang_C, "input1.c");
+ Decl *FromTU1 = getTuDecl(Code, Lang_C99, "input1.c");
auto *X0 =
FirstDeclMatcher<RecordDecl>().match(FromTU0, recordDecl(hasName("X")));
auto *X1 =
FirstDeclMatcher<RecordDecl>().match(FromTU1, recordDecl(hasName("X")));
- Import(X0, Lang_C);
- Import(X1, Lang_C);
+ Import(X0, Lang_C99);
+ Import(X1, Lang_C99);
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
// We expect no (ODR) warning during the import.
struct { int b; };
};
)",
- Lang_C, "input0.c");
+ Lang_C99, "input0.c");
Decl *FromTU1 = getTuDecl(
R"(
struct { int a; };
};
)",
- Lang_C, "input1.c");
+ Lang_C99, "input1.c");
auto *X0 =
FirstDeclMatcher<RecordDecl>().match(FromTU0, recordDecl(hasName("X")));
auto *X1 =
FirstDeclMatcher<RecordDecl>().match(FromTU1, recordDecl(hasName("X")));
- Import(X0, Lang_C);
- Import(X1, Lang_C);
+ Import(X0, Lang_C99);
+ Import(X1, Lang_C99);
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
// We expect one (ODR) warning during the import.
auto Pattern = varDecl(hasName("x"));
VarDecl *Imported1;
{
- Decl *FromTU = getTuDecl("extern int x;", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("extern int x;", Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX));
+ Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX03));
}
VarDecl *Imported2;
{
- Decl *FromTU = getTuDecl("int x;", Lang_CXX, "input1.cc");
+ Decl *FromTU = getTuDecl("int x;", Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX));
+ Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX03));
}
EXPECT_EQ(Imported1->getCanonicalDecl(), Imported2->getCanonicalDecl());
EXPECT_FALSE(Imported2->isUsed(false));
{
- Decl *FromTU =
- getTuDecl("extern int x; int f() { return x; }", Lang_CXX, "input2.cc");
+ Decl *FromTU = getTuDecl("extern int x; int f() { return x; }", Lang_CXX03,
+ "input2.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
EXPECT_TRUE(Imported2->isUsed(false));
}
auto Pattern = varDecl(hasName("x"));
VarDecl *ExistingD;
{
- Decl *ToTU = getToTuDecl("int x = 1;", Lang_CXX);
+ Decl *ToTU = getToTuDecl("int x = 1;", Lang_CXX03);
ExistingD = FirstDeclMatcher<VarDecl>().match(ToTU, Pattern);
}
EXPECT_FALSE(ExistingD->isUsed(false));
{
- Decl *FromTU = getTuDecl(
- "int x = 1; int f() { return x; }", Lang_CXX, "input1.cc");
+ Decl *FromTU =
+ getTuDecl("int x = 1; int f() { return x; }", Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
EXPECT_TRUE(ExistingD->isUsed(false));
}
struct A {
static const int a = 1;
};
- )", Lang_CXX);
+ )",
+ Lang_CXX03);
ExistingD = FirstDeclMatcher<VarDecl>().match(ToTU, Pattern);
}
EXPECT_FALSE(ExistingD->isUsed(false));
};
const int *f() { return &A::a; } // requires storage,
// thus used flag will be set
- )", Lang_CXX, "input1.cc");
+ )",
+ Lang_CXX03, "input1.cc");
auto *FromFunD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
ASSERT_TRUE(FromD->isUsed(false));
- Import(FromFunD, Lang_CXX);
+ Import(FromFunD, Lang_CXX03);
}
EXPECT_TRUE(ExistingD->isUsed(false));
}
TEST_P(ASTImporterOptionSpecificTestBase, ReimportWithUsedFlag) {
auto Pattern = varDecl(hasName("x"));
- Decl *FromTU = getTuDecl("int x;", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("int x;", Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- auto *Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX));
+ auto *Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX03));
ASSERT_FALSE(Imported1->isUsed(false));
FromD->setIsUsed();
- auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX));
+ auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX03));
EXPECT_EQ(Imported1, Imported2);
EXPECT_TRUE(Imported2->isUsed(false));
struct ImportFunctions : ASTImporterOptionSpecificTestBase {};
TEST_P(ImportFunctions, ImportPrototypeOfRecursiveFunction) {
- Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX);
+ Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX03);
auto Pattern = functionDecl(hasName("f"));
auto *From =
FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern); // Proto
- Decl *ImportedD = Import(From, Lang_CXX);
+ Decl *ImportedD = Import(From, Lang_CXX03);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
}
TEST_P(ImportFunctions, ImportDefinitionOfRecursiveFunction) {
- Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX);
+ Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX03);
auto Pattern = functionDecl(hasName("f"));
auto *From =
LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern); // Def
- Decl *ImportedD = Import(From, Lang_CXX);
+ Decl *ImportedD = Import(From, Lang_CXX03);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
)";
auto Pattern =
cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))));
- Decl *FromTU = getTuDecl(Code, Lang_CXX);
+ Decl *FromTU = getTuDecl(Code, Lang_CXX03);
CXXMethodDecl *Proto =
FirstDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
ASSERT_EQ(Proto->size_overridden_methods(), 1u);
- CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX));
+ CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX03));
EXPECT_EQ(To->size_overridden_methods(), 1u);
}
)";
auto Pattern =
cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("B"))));
- Decl *FromTU = getTuDecl(Code, Lang_CXX);
+ Decl *FromTU = getTuDecl(Code, Lang_CXX03);
CXXMethodDecl *Proto =
FirstDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
CXXMethodDecl *Def = LastDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
ASSERT_TRUE(Proto->isVirtual());
ASSERT_TRUE(Def->isVirtual());
- CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX));
+ CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX03));
EXPECT_TRUE(To->isVirtual());
}
void f() {}
void f();
)",
- Lang_CXX);
+ Lang_CXX03);
ASSERT_EQ(1u,
DeclCounterWithPredicate<FunctionDecl>([](const FunctionDecl *FD) {
return FD->doesThisDeclarationHaveABody();
}).match(ToTU, functionDecl()));
- Decl *FromTU = getTuDecl("void f() {}", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("void f() {}", Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
EXPECT_EQ(1u,
DeclCounterWithPredicate<FunctionDecl>([](const FunctionDecl *FD) {
auto DFP =
cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))));
- Decl *FromTU0 = getTuDecl(Code, Lang_CXX);
+ Decl *FromTU0 = getTuDecl(Code, Lang_CXX03);
auto *DF = FirstDeclMatcher<CXXMethodDecl>().match(FromTU0, DFP);
- Import(DF, Lang_CXX);
+ Import(DF, Lang_CXX03);
- Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+ Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
auto *BF = FirstDeclMatcher<CXXMethodDecl>().match(FromTU1, BFP);
- Import(BF, Lang_CXX);
+ Import(BF, Lang_CXX03);
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto FDefAllP = cxxMethodDecl(hasName("f"), isDefinition());
{
- Decl *FromTU = getTuDecl(CodeWithDef, Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl(CodeWithDef, Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<CXXMethodDecl>().match(FromTU, DFP);
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
{
- Decl *FromTU = getTuDecl(CodeWithoutDef, Lang_CXX, "input1.cc");
+ Decl *FromTU = getTuDecl(CodeWithoutDef, Lang_CXX03, "input1.cc");
auto *FromB = FirstDeclMatcher<CXXMethodDecl>().match(FromTU, BFP);
- Import(FromB, Lang_CXX);
+ Import(FromB, Lang_CXX03);
}
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto DFP = cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))),
unless(isDefinition()));
- Decl *FromTU0 = getTuDecl(Code, Lang_CXX);
+ Decl *FromTU0 = getTuDecl(Code, Lang_CXX03);
auto *D = FirstDeclMatcher<CXXMethodDecl>().match(FromTU0, DFP);
- Import(D, Lang_CXX);
+ Import(D, Lang_CXX03);
- Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+ Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
auto *B = FirstDeclMatcher<CXXMethodDecl>().match(FromTU1, BFP);
- Import(B, Lang_CXX);
+ Import(B, Lang_CXX03);
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto FooDef = functionDecl(hasName("foo"));
{
- Decl *FromTU0 = getTuDecl(CodeTU0, Lang_CXX, "input0.cc");
+ Decl *FromTU0 = getTuDecl(CodeTU0, Lang_CXX03, "input0.cc");
auto *D = FirstDeclMatcher<CXXMethodDecl>().match(FromTU0, DFP);
- Import(D, Lang_CXX);
+ Import(D, Lang_CXX03);
}
{
- Decl *FromTU1 = getTuDecl(CodeTU1, Lang_CXX, "input1.cc");
+ Decl *FromTU1 = getTuDecl(CodeTU1, Lang_CXX03, "input1.cc");
auto *Foo = FirstDeclMatcher<FunctionDecl>().match(FromTU1, FooDef);
- Import(Foo, Lang_CXX);
+ Import(Foo, Lang_CXX03);
}
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
std::string Code = "static int v; static int v = 0;";
auto Pattern = varDecl(hasName("v"));
- TranslationUnitDecl *FromTu = getTuDecl(Code, Lang_C, "input0.c");
+ TranslationUnitDecl *FromTu = getTuDecl(Code, Lang_C99, "input0.c");
auto *From0 = FirstDeclMatcher<VarDecl>().match(FromTu, Pattern);
auto *From1 = LastDeclMatcher<VarDecl>().match(FromTu, Pattern);
- auto *To0 = Import(From0, Lang_C);
- auto *To1 = Import(From1, Lang_C);
+ auto *To0 = Import(From0, Lang_C99);
+ auto *To1 = Import(From1, Lang_C99);
EXPECT_TRUE(To0);
ASSERT_TRUE(To1);
}
TEST_P(ImportFunctions, ImportFromDifferentScopedAnonNamespace) {
- TranslationUnitDecl *FromTu = getTuDecl(
- "namespace NS0 { namespace { void f(); } }"
- "namespace NS1 { namespace { void f(); } }",
- Lang_CXX, "input0.cc");
+ TranslationUnitDecl *FromTu =
+ getTuDecl("namespace NS0 { namespace { void f(); } }"
+ "namespace NS1 { namespace { void f(); } }",
+ Lang_CXX03, "input0.cc");
auto Pattern = functionDecl(hasName("f"));
auto *FromF0 = FirstDeclMatcher<FunctionDecl>().match(FromTu, Pattern);
auto *FromF1 = LastDeclMatcher<FunctionDecl>().match(FromTu, Pattern);
- auto *ToF0 = Import(FromF0, Lang_CXX);
- auto *ToF1 = Import(FromF1, Lang_CXX);
+ auto *ToF0 = Import(FromF0, Lang_CXX03);
+ auto *ToF1 = Import(FromF1, Lang_CXX03);
EXPECT_TRUE(ToF0);
ASSERT_TRUE(ToF1);
TEST_P(ImportFunctions, ImportFunctionFromUnnamedNamespace) {
{
Decl *FromTU = getTuDecl("namespace { void f() {} } void g0() { f(); }",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("g0")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
{
Decl *FromTU =
getTuDecl("namespace { void f() { int a; } } void g1() { f(); }",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("g1")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
Lang_CXX11);
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("foo")));
- auto *ToD = Import(FromD, Lang_CXX);
+ auto *ToD = Import(FromD, Lang_CXX03);
EXPECT_TRUE(ToD);
CXXRecordDecl *LambdaRec =
cast<LambdaExpr>(cast<CStyleCastExpr>(
x.foo<int>();
}
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
- auto *ToD = Import(FromD, Lang_CXX);
+ auto *ToD = Import(FromD, Lang_CXX03);
EXPECT_TRUE(ToD);
EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
ToD, functionDecl(hasName("f"), hasDescendant(declRefExpr()))));
f<int>();
}
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("g")));
- auto *ToD = Import(FromD, Lang_CXX);
+ auto *ToD = Import(FromD, Lang_CXX03);
EXPECT_TRUE(ToD);
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
EXPECT_TRUE(MatchVerifier<TranslationUnitDecl>().match(
void f(T t);
};
)";
- Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+ Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
auto *FromD1 = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU1, functionTemplateDecl(hasName("f")));
- auto *ToD1 = Import(FromD1, Lang_CXX);
- Decl *FromTU2 = getTuDecl(Code, Lang_CXX, "input2.cc");
+ auto *ToD1 = Import(FromD1, Lang_CXX03);
+ Decl *FromTU2 = getTuDecl(Code, Lang_CXX03, "input2.cc");
auto *FromD2 = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU2, functionTemplateDecl(hasName("f")));
- auto *ToD2 = Import(FromD2, Lang_CXX);
+ auto *ToD2 = Import(FromD2, Lang_CXX03);
EXPECT_EQ(ToD1, ToD2);
}
template <class T>
void X::f(T t) {};
)";
- Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+ Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
auto *FromD1 = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU1, functionTemplateDecl(hasName("f")));
- auto *ToD1 = Import(FromD1, Lang_CXX);
- Decl *FromTU2 = getTuDecl(Code, Lang_CXX, "input2.cc");
+ auto *ToD1 = Import(FromD1, Lang_CXX03);
+ Decl *FromTU2 = getTuDecl(Code, Lang_CXX03, "input2.cc");
auto *FromD2 = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU2, functionTemplateDecl(hasName("f")));
- auto *ToD2 = Import(FromD2, Lang_CXX);
+ auto *ToD2 = Import(FromD2, Lang_CXX03);
EXPECT_EQ(ToD1, ToD2);
}
void foo(T) {}
void foo();
)",
- Lang_CXX);
- Decl *FromTU = getTuDecl("void foo();", Lang_CXX);
+ Lang_CXX03);
+ Decl *FromTU = getTuDecl("void foo();", Lang_CXX03);
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("foo")));
- auto *ImportedD = Import(FromD, Lang_CXX);
+ auto *ImportedD = Import(FromD, Lang_CXX03);
EXPECT_TRUE(ImportedD);
}
Foo();
};
)";
- getToTuDecl(Code, Lang_CXX);
- Decl *FromTU = getTuDecl(Code, Lang_CXX);
+ getToTuDecl(Code, Lang_CXX03);
+ Decl *FromTU = getTuDecl(Code, Lang_CXX03);
auto *FromD =
LastDeclMatcher<CXXConstructorDecl>().match(FromTU, cxxConstructorDecl());
- auto *ImportedD = Import(FromD, Lang_CXX);
+ auto *ImportedD = Import(FromD, Lang_CXX03);
EXPECT_TRUE(ImportedD);
}
struct X{};
void operator<(X, X);
)",
- Lang_CXX);
+ Lang_CXX03);
Decl *FromTU = getTuDecl(
R"(
struct X{};
void operator<(X, X);
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromD = LastDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasOverloadedOperatorName("<")));
- auto *ImportedD = Import(FromD, Lang_CXX);
+ auto *ImportedD = Import(FromD, Lang_CXX03);
EXPECT_TRUE(ImportedD);
}
Decl *FromTU = getTuDecl("struct X { friend void f(); };"
"void f();",
- Lang_CXX,
- "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
Decl *FromTU = getTuDecl("void f();"
"struct X { friend void f(); };",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
Decl *FromTU = getTuDecl("struct X { friend void f(){} };"
"void f();",
- Lang_CXX,
- "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
Decl *FromTU = getTuDecl("struct X { friend void f(); };"
"void f(){}",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
friend void f(X *x);
};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
friend void f(X *x);
};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
FunctionDecl *ImportedD;
{
Decl *FromTU =
- getTuDecl("struct X { friend void f(){} };", Lang_CXX, "input0.cc");
+ getTuDecl("struct X { friend void f(){} };", Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
}
FunctionDecl *ImportedD1;
{
- Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input1.cc");
+ Decl *FromTU = getTuDecl("void f();", Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
- ImportedD1 = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ ImportedD1 = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto ClassPattern = cxxRecordDecl(hasName("X"));
TranslationUnitDecl *FromTU =
- getTuDecl("struct X { friend void f(); };", Lang_CXX, "input0.cc");
+ getTuDecl("struct X { friend void f(); };", Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
ASSERT_TRUE(FromD->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
ASSERT_FALSE(FromD->isInIdentifierNamespace(Decl::IDNS_Ordinary));
ASSERT_EQ(LookupRes.size(), 1u);
}
- auto *ToD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+ auto *ToD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
auto ToName = ToD->getDeclName();
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto FunctionPattern = functionDecl(hasName("f"));
auto ClassPattern = cxxRecordDecl(hasName("X"));
- TranslationUnitDecl *FromTU = getTuDecl(
- "struct X { friend void f(); };"
- // This proto decl makes f available to normal
- // lookup, otherwise it is hidden.
- // Normal C++ lookup (implemented in
- // `clang::Sema::CppLookupName()` and in `LookupDirect()`)
- // returns the found `NamedDecl` only if the set IDNS is matched
- "void f();",
- Lang_CXX, "input0.cc");
+ TranslationUnitDecl *FromTU =
+ getTuDecl("struct X { friend void f(); };"
+ // This proto decl makes f available to normal
+ // lookup, otherwise it is hidden.
+ // Normal C++ lookup (implemented in
+ // `clang::Sema::CppLookupName()` and in `LookupDirect()`)
+ // returns the found `NamedDecl` only if the set IDNS is matched
+ "void f();",
+ Lang_CXX03, "input0.cc");
auto *FromFriend =
FirstDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
auto *FromNormal =
LookupRes = FromTU->noload_lookup(FromName);
ASSERT_EQ(LookupRes.size(), 1u);
- auto *ToFriend = cast<FunctionDecl>(Import(FromFriend, Lang_CXX));
+ auto *ToFriend = cast<FunctionDecl>(Import(FromFriend, Lang_CXX03));
auto ToName = ToFriend->getDeclName();
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto FunctionPattern = functionDecl(hasName("f"));
auto ClassPattern = cxxRecordDecl(hasName("X"));
- TranslationUnitDecl *FromTU = getTuDecl(
- "void f();"
- "struct X { friend void f(); };",
- Lang_CXX, "input0.cc");
+ TranslationUnitDecl *FromTU = getTuDecl("void f();"
+ "struct X { friend void f(); };",
+ Lang_CXX03, "input0.cc");
auto *FromNormal =
FirstDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
auto *FromFriend =
LookupRes = FromTU->noload_lookup(FromName);
ASSERT_EQ(LookupRes.size(), 1u);
- auto *ToNormal = cast<FunctionDecl>(Import(FromNormal, Lang_CXX));
+ auto *ToNormal = cast<FunctionDecl>(Import(FromNormal, Lang_CXX03));
auto ToName = ToNormal->getDeclName();
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto Pattern = functionDecl(hasName("f"));
TranslationUnitDecl *FromNormalTU =
- getTuDecl("void f();", Lang_CXX, "input0.cc");
+ getTuDecl("void f();", Lang_CXX03, "input0.cc");
auto *FromNormalF =
FirstDeclMatcher<FunctionDecl>().match(FromNormalTU, Pattern);
TranslationUnitDecl *FromFriendTU =
- getTuDecl("class X { friend void f(); };", Lang_CXX, "input1.cc");
+ getTuDecl("class X { friend void f(); };", Lang_CXX03, "input1.cc");
auto *FromFriendF =
FirstDeclMatcher<FunctionDecl>().match(FromFriendTU, Pattern);
auto FromNormalName = FromNormalF->getDeclName();
LookupRes = FromFriendTU->noload_lookup(FromFriendName);
ASSERT_EQ(LookupRes.size(), 1u);
- auto *ToNormalF = cast<FunctionDecl>(Import(FromNormalF, Lang_CXX));
+ auto *ToNormalF = cast<FunctionDecl>(Import(FromNormalF, Lang_CXX03));
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto ToName = ToNormalF->getDeclName();
EXPECT_TRUE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
EXPECT_EQ(LookupRes.size(), 1u);
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 1u);
- auto *ToFriendF = cast<FunctionDecl>(Import(FromFriendF, Lang_CXX));
+ auto *ToFriendF = cast<FunctionDecl>(Import(FromFriendF, Lang_CXX03));
LookupRes = ToTU->noload_lookup(ToName);
EXPECT_EQ(LookupRes.size(), 1u);
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
}
TEST_P(ImportFriendFunctions, ImportFriendList) {
- TranslationUnitDecl *FromTU = getTuDecl(
- "struct X { friend void f(); };"
- "void f();",
- Lang_CXX, "input0.cc");
+ TranslationUnitDecl *FromTU = getTuDecl("struct X { friend void f(); };"
+ "void f();",
+ Lang_CXX03, "input0.cc");
auto *FromFriendF = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
}
ASSERT_EQ(FrN, 1u);
- Import(FromFriendF, Lang_CXX);
+ Import(FromFriendF, Lang_CXX03);
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto *ToClass = FirstDeclMatcher<CXXRecordDecl>().match(
ToTU, cxxRecordDecl(hasName("X")));
{"void foo();"
"void moo();"
"int main() { foo(); moo(); }",
- Lang_C}},
+ Lang_C99}},
{"foo.c",
{"typedef enum { THING_VALUE } thing_t;"
"void conflict(thing_t type);"
"void foo() { (void)THING_VALUE; }"
"void conflict(thing_t type) {}",
- Lang_C}},
+ Lang_C99}},
{"moo.c",
{"typedef enum { THING_VALUE } thing_t;"
"void conflict(thing_t type);"
"void moo() { conflict(THING_VALUE); }",
- Lang_C}}};
+ Lang_C99}}};
auto VerificationMatcher =
enumDecl(has(enumConstantDecl(hasName("THING_VALUE"))),
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentRecord) {
Decl *ToR1;
{
- Decl *FromTU = getTuDecl(
- "struct A { };", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("struct A { };", Lang_CXX03, "input0.cc");
auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("A")));
- ToR1 = Import(FromR, Lang_CXX);
+ ToR1 = Import(FromR, Lang_CXX03);
}
Decl *ToR2;
{
- Decl *FromTU = getTuDecl(
- "struct A { };", Lang_CXX, "input1.cc");
+ Decl *FromTU = getTuDecl("struct A { };", Lang_CXX03, "input1.cc");
auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("A")));
- ToR2 = Import(FromR, Lang_CXX);
+ ToR2 = Import(FromR, Lang_CXX03);
}
EXPECT_EQ(ToR1, ToR2);
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentRecord) {
Decl *ToR1;
{
- Decl *FromTU = getTuDecl(
- "struct A { int x; };", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input0.cc");
auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("A")));
- ToR1 = Import(FromR, Lang_CXX);
+ ToR1 = Import(FromR, Lang_CXX03);
}
Decl *ToR2;
{
- Decl *FromTU = getTuDecl(
- "struct A { unsigned x; };", Lang_CXX, "input1.cc");
+ Decl *FromTU =
+ getTuDecl("struct A { unsigned x; };", Lang_CXX03, "input1.cc");
auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("A")));
- ToR2 = Import(FromR, Lang_CXX);
+ ToR2 = Import(FromR, Lang_CXX03);
}
EXPECT_NE(ToR1, ToR2);
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentField) {
Decl *ToF1;
{
- Decl *FromTU = getTuDecl(
- "struct A { int x; };", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input0.cc");
auto *FromF = FirstDeclMatcher<FieldDecl>().match(
FromTU, fieldDecl(hasName("x")));
- ToF1 = Import(FromF, Lang_CXX);
+ ToF1 = Import(FromF, Lang_CXX03);
}
Decl *ToF2;
{
- Decl *FromTU = getTuDecl(
- "struct A { int x; };", Lang_CXX, "input1.cc");
+ Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input1.cc");
auto *FromF = FirstDeclMatcher<FieldDecl>().match(
FromTU, fieldDecl(hasName("x")));
- ToF2 = Import(FromF, Lang_CXX);
+ ToF2 = Import(FromF, Lang_CXX03);
}
EXPECT_EQ(ToF1, ToF2);
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentField) {
Decl *ToF1;
{
- Decl *FromTU = getTuDecl(
- "struct A { int x; };", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input0.cc");
auto *FromF = FirstDeclMatcher<FieldDecl>().match(
FromTU, fieldDecl(hasName("x")));
- ToF1 = Import(FromF, Lang_CXX);
+ ToF1 = Import(FromF, Lang_CXX03);
}
Decl *ToF2;
{
- Decl *FromTU = getTuDecl(
- "struct A { unsigned x; };", Lang_CXX, "input1.cc");
+ Decl *FromTU =
+ getTuDecl("struct A { unsigned x; };", Lang_CXX03, "input1.cc");
auto *FromF = FirstDeclMatcher<FieldDecl>().match(
FromTU, fieldDecl(hasName("x")));
- ToF2 = Import(FromF, Lang_CXX);
+ ToF2 = Import(FromF, Lang_CXX03);
}
EXPECT_NE(ToF1, ToF2);
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentMethod) {
Decl *ToM1;
{
- Decl *FromTU = getTuDecl(
- "struct A { void x(); }; void A::x() { }", Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("struct A { void x(); }; void A::x() { }",
+ Lang_CXX03, "input0.cc");
auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("x"), isDefinition()));
- ToM1 = Import(FromM, Lang_CXX);
+ ToM1 = Import(FromM, Lang_CXX03);
}
Decl *ToM2;
{
- Decl *FromTU = getTuDecl(
- "struct A { void x(); }; void A::x() { }", Lang_CXX, "input1.cc");
+ Decl *FromTU = getTuDecl("struct A { void x(); }; void A::x() { }",
+ Lang_CXX03, "input1.cc");
auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("x"), isDefinition()));
- ToM2 = Import(FromM, Lang_CXX);
+ ToM2 = Import(FromM, Lang_CXX03);
}
EXPECT_EQ(ToM1, ToM2);
}
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentMethod) {
Decl *ToM1;
{
- Decl *FromTU = getTuDecl(
- "struct A { void x(); }; void A::x() { }",
- Lang_CXX, "input0.cc");
+ Decl *FromTU = getTuDecl("struct A { void x(); }; void A::x() { }",
+ Lang_CXX03, "input0.cc");
auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("x"), isDefinition()));
- ToM1 = Import(FromM, Lang_CXX);
+ ToM1 = Import(FromM, Lang_CXX03);
}
Decl *ToM2;
{
- Decl *FromTU = getTuDecl(
- "struct A { void x() const; }; void A::x() const { }",
- Lang_CXX, "input1.cc");
+ Decl *FromTU =
+ getTuDecl("struct A { void x() const; }; void A::x() const { }",
+ Lang_CXX03, "input1.cc");
auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("x"), isDefinition()));
- ToM2 = Import(FromM, Lang_CXX);
+ ToM2 = Import(FromM, Lang_CXX03);
}
EXPECT_NE(ToM1, ToM2);
}
} entry1;
};
)",
- Lang_C, "input0.cc");
+ Lang_C99, "input0.cc");
auto *From =
FirstDeclMatcher<RecordDecl>().match(FromTU, recordDecl(hasName("A")));
- Import(From, Lang_C);
+ Import(From, Lang_C99);
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
auto *Entry0 =
static const int a = 1 + 2;
};
const int A::a;
- )", Lang_CXX, "input1.cc");
+ )",
+ Lang_CXX03, "input1.cc");
auto *FromDWithInit = FirstDeclMatcher<VarDecl>().match(
FromTU, varDecl(hasName("a"))); // Decl with init
static const int a = 1 + 2;
};
)";
- Decl *ToTU = getToTuDecl(StructA, Lang_CXX);
- Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a;", Lang_CXX,
+ Decl *ToTU = getToTuDecl(StructA, Lang_CXX03);
+ Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a;", Lang_CXX03,
"input1.cc");
auto *FromDWithInit = FirstDeclMatcher<VarDecl>().match(
static const int a;
};
)";
- Decl *ToTU = getToTuDecl(StructA, Lang_CXX);
+ Decl *ToTU = getToTuDecl(StructA, Lang_CXX03);
Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a = 1 + 2;",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *FromDDeclarationOnly = FirstDeclMatcher<VarDecl>().match(
FromTU, varDecl(hasName("a")));
struct ImportClasses : ASTImporterOptionSpecificTestBase {};
TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContext) {
- Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C);
- Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "input1.cc");
+ Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C99);
+ Decl *FromTU1 = getTuDecl("struct X {};", Lang_C99, "input1.cc");
auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
- Decl *ImportedDef = Import(FromDef, Lang_C);
+ Decl *ImportedDef = Import(FromDef, Lang_C99);
EXPECT_NE(ImportedDef, ToProto);
EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
}
TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContextCXX) {
- Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_CXX);
- Decl *FromTU1 = getTuDecl("struct X {};", Lang_CXX, "input1.cc");
+ Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_CXX03);
+ Decl *FromTU1 = getTuDecl("struct X {};", Lang_CXX03, "input1.cc");
auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
- Decl *ImportedDef = Import(FromDef, Lang_CXX);
+ Decl *ImportedDef = Import(FromDef, Lang_CXX03);
EXPECT_NE(ImportedDef, ToProto);
EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
}
TEST_P(ImportClasses, ImportNestedPrototypeThenDefinition) {
- Decl *FromTU0 = getTuDecl("struct A { struct X *Xp; };", Lang_C, "input0.cc");
- Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "input1.cc");
+ Decl *FromTU0 =
+ getTuDecl("struct A { struct X *Xp; };", Lang_C99, "input0.cc");
+ Decl *FromTU1 = getTuDecl("struct X {};", Lang_C99, "input1.cc");
auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
auto FromProto = FirstDeclMatcher<RecordDecl>().match(FromTU0, Pattern);
auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
- Decl *ImportedProto = Import(FromProto, Lang_C);
- Decl *ImportedDef = Import(FromDef, Lang_C);
+ Decl *ImportedProto = Import(FromProto, Lang_C99);
+ Decl *ImportedDef = Import(FromDef, Lang_C99);
Decl *ToTU = ImportedDef->getTranslationUnitDecl();
EXPECT_NE(ImportedDef, ImportedProto);
};
};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromClass = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("F"), isDefinition()));
ASSERT_EQ(FromFriendClass->getDescribedClassTemplate()->getPreviousDecl(),
FromClass->getDescribedClassTemplate());
- auto *ToClass = cast<CXXRecordDecl>(Import(FromClass, Lang_CXX));
- auto *ToFriendClass = cast<CXXRecordDecl>(Import(FromFriendClass, Lang_CXX));
+ auto *ToClass = cast<CXXRecordDecl>(Import(FromClass, Lang_CXX03));
+ auto *ToFriendClass =
+ cast<CXXRecordDecl>(Import(FromFriendClass, Lang_CXX03));
EXPECT_TRUE(ToClass);
EXPECT_TRUE(ToFriendClass);
friend class declToImport;
};
)",
- Lang_CXX, "input.cc");
+ Lang_CXX03, "input.cc");
auto *FromD = FirstDeclMatcher<CXXRecordDecl>().match(
FromTu, cxxRecordDecl(hasName("declToImport")));
- auto *ToD = Import(FromD, Lang_CXX);
+ auto *ToD = Import(FromD, Lang_CXX03);
auto Pattern = cxxRecordDecl(has(friendDecl()));
ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromD, Pattern));
EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToD, Pattern));
}
TEST_P(ImportFriendClasses, UndeclaredFriendClassShouldNotBeVisible) {
- Decl *FromTu = getTuDecl("class X { friend class Y; };", Lang_CXX, "from.cc");
+ Decl *FromTu =
+ getTuDecl("class X { friend class Y; };", Lang_CXX03, "from.cc");
auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
FromTu, cxxRecordDecl(hasName("X")));
auto *FromFriend = FirstDeclMatcher<FriendDecl>().match(FromTu, friendDecl());
->lookup(FromRecordOfFriend->getDeclName())
.empty());
- auto *ToX = Import(FromX, Lang_CXX);
+ auto *ToX = Import(FromX, Lang_CXX03);
ASSERT_TRUE(ToX);
Decl *ToTu = ToX->getTranslationUnitDecl();
template<class A1> friend class declToImport;
};
)",
- Lang_CXX, "input.cc");
+ Lang_CXX03, "input.cc");
auto *FromD =
FirstDeclMatcher<ClassTemplateDecl>().match(FromTu, classTemplateDecl());
- auto *ToD = Import(FromD, Lang_CXX);
+ auto *ToD = Import(FromD, Lang_CXX03);
auto Pattern = classTemplateDecl(
has(cxxRecordDecl(has(friendDecl(has(classTemplateDecl()))))));
{
Decl *FromTU = getTuDecl("template<class T> class X;"
"struct Y { friend class X<int>; };",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
FromTU, Pattern);
- Imported1 = cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX));
+ Imported1 =
+ cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX03));
}
ClassTemplateSpecializationDecl *Imported2;
{
Decl *FromTU = getTuDecl("template<class T> class X;"
"template<> class X<int>{};"
"struct Z { friend class X<int>; };",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *FromD = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
FromTU, Pattern);
- Imported2 = cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX));
+ Imported2 =
+ cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX03));
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
friend class F; // The decl context of F is the global namespace.
};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *Fwd = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU0, classTemplateDecl(hasName("F")));
- auto *Imported0 = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX));
+ auto *Imported0 = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX03));
Decl *FromTU1 = getTuDecl(
R"(
template <typename T>
class F {};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU1, classTemplateDecl(hasName("F")));
- auto *Imported1 = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX));
+ auto *Imported1 = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
EXPECT_EQ(Imported0->getTemplatedDecl()->getTypeForDecl(),
Imported1->getTemplatedDecl()->getTypeForDecl());
}
TEST_P(ImportFriendClasses, DeclsFromFriendsShouldBeInRedeclChains) {
Decl *From, *To;
std::tie(From, To) =
- getImportedDecl("class declToImport {};", Lang_CXX,
- "class Y { friend class declToImport; };", Lang_CXX);
+ getImportedDecl("class declToImport {};", Lang_CXX03,
+ "class Y { friend class declToImport; };", Lang_CXX03);
auto *Imported = cast<CXXRecordDecl>(To);
EXPECT_TRUE(Imported->getPreviousDecl());
friend class F; // The decl context of F is the global namespace.
};
)",
- Lang_CXX);
+ Lang_CXX03);
auto *ToDecl = FirstDeclMatcher<ClassTemplateDecl>().match(
ToTU, classTemplateDecl(hasName("F")));
Decl *FromTU = getTuDecl(
template <typename T>
class F {};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU, classTemplateDecl(hasName("F")));
- auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX));
+ auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
EXPECT_TRUE(ImportedDef->getPreviousDecl());
EXPECT_EQ(ToDecl, ImportedDef->getPreviousDecl());
EXPECT_EQ(ToDecl->getTemplatedDecl(),
friend class F; // The decl context of F is the global namespace.
};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *Fwd = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU0, classTemplateDecl(hasName("F")));
- auto *ImportedFwd = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX));
+ auto *ImportedFwd = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX03));
Decl *FromTU1 = getTuDecl(
R"(
template <typename T>
class F {};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU1, classTemplateDecl(hasName("F")));
- auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX));
+ auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
EXPECT_TRUE(ImportedDef->getPreviousDecl());
EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
EXPECT_EQ(ImportedFwd->getTemplatedDecl(),
friend class F; // The decl context of F is the global namespace.
};
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *Friend = FirstDeclMatcher<FriendDecl>().match(FromTU0, friendDecl());
QualType FT = Friend->getFriendType()->getType();
FT = FromTU0->getASTContext().getCanonicalType(FT);
auto *Fwd = cast<TagType>(FT)->getDecl();
- auto *ImportedFwd = Import(Fwd, Lang_CXX);
+ auto *ImportedFwd = Import(Fwd, Lang_CXX03);
Decl *FromTU1 = getTuDecl(
R"(
class F {};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *Definition = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU1, cxxRecordDecl(hasName("F")));
- auto *ImportedDef = Import(Definition, Lang_CXX);
+ auto *ImportedDef = Import(Definition, Lang_CXX03);
EXPECT_TRUE(ImportedDef->getPreviousDecl());
EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
}
friend void foo(){}
};
)";
- TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
+ TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX03);
auto *ToFoo = FirstDeclMatcher<FunctionDecl>().match(
ToTU, functionDecl(hasName("foo")));
- TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX, "input.cc");
+ TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX03, "input.cc");
auto *FromFoo = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("foo")));
- auto *ImportedFoo = Import(FromFoo, Lang_CXX);
+ auto *ImportedFoo = Import(FromFoo, Lang_CXX03);
EXPECT_EQ(ImportedFoo, ToFoo);
}
TEST_P(DeclContextTest,
removeDeclShouldNotFailEvenIfWeHaveExternalVisibleStorage) {
- Decl *TU = getTuDecl("extern int A; int A;", Lang_CXX);
+ Decl *TU = getTuDecl("extern int A; int A;", Lang_CXX03);
auto *A0 = FirstDeclMatcher<VarDecl>().match(TU, varDecl(hasName("A")));
auto *A1 = LastDeclMatcher<VarDecl>().match(TU, varDecl(hasName("A")));
int f() { return 0; }
void foo() { f<int>(); }
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
// Check that the function template instantiation is NOT the child of the TU.
auto Pattern = translationUnitDecl(
auto *Foo = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("foo")));
- ASSERT_TRUE(Import(Foo, Lang_CXX));
+ ASSERT_TRUE(Import(Foo, Lang_CXX03));
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
int f() { return 0; }
template int f<int>();
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
// Check that the function template instantiation is NOT the child of the TU.
auto Instantiation = functionDecl(hasName("f"), isTemplateInstantiation());
auto Pattern = translationUnitDecl(unless(has(Instantiation)));
ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
- ASSERT_TRUE(
- Import(FirstDeclMatcher<Decl>().match(FromTU, Instantiation), Lang_CXX));
+ ASSERT_TRUE(Import(FirstDeclMatcher<Decl>().match(FromTU, Instantiation),
+ Lang_CXX03));
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
int f() { return 0; }
template <> int f<int>() { return 4; }
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
// Check that the function template specialization is the child of the TU.
auto Specialization =
auto Pattern = translationUnitDecl(has(Specialization));
ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
- ASSERT_TRUE(
- Import(FirstDeclMatcher<Decl>().match(FromTU, Specialization), Lang_CXX));
+ ASSERT_TRUE(Import(FirstDeclMatcher<Decl>().match(FromTU, Specialization),
+ Lang_CXX03));
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
int f() { return 0; }
template <> int f<int>() { return 4; }
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto Spec = functionDecl(hasName("f"), isExplicitTemplateSpecialization(),
hasParent(translationUnitDecl()));
->doesThisDeclarationHaveABody());
}
- ASSERT_TRUE(Import(FromSpecD, Lang_CXX));
+ ASSERT_TRUE(Import(FromSpecD, Lang_CXX03));
{
auto *TU = ToAST->getASTContext().getTranslationUnitDecl();
template <typename T>
struct B;
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU, classTemplateDecl(hasName("B")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
}
{
B* b;
};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
FunctionDecl *FromD = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
- Import(FromD, Lang_CXX);
+ Import(FromD, Lang_CXX03);
auto *FromCTD = FirstDeclMatcher<ClassTemplateDecl>().match(
FromTU, classTemplateDecl(hasName("B")));
- auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX));
+ auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX03));
EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
// We expect no (ODR) warning during the import.
template <> int f<int>() { return 4; }
)";
- Decl *FromTU = getTuDecl(Code, Lang_CXX);
+ Decl *FromTU = getTuDecl(Code, Lang_CXX03);
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU,
functionDecl(hasName("f"), isExplicitTemplateSpecialization()));
ASSERT_EQ(FromD->getNumTemplateParameterLists(), 1u);
- auto *ToD = Import(FromD, Lang_CXX);
+ auto *ToD = Import(FromD, Lang_CXX03);
// The template parameter list should exist.
EXPECT_EQ(ToD->getNumTemplateParameterLists(), 1u);
}
struct ASTImporterLookupTableTest : ASTImporterOptionSpecificTestBase {};
TEST_P(ASTImporterLookupTableTest, OneDecl) {
- auto *ToTU = getToTuDecl("int a;", Lang_CXX);
+ auto *ToTU = getToTuDecl("int a;", Lang_CXX03);
auto *D = FirstDeclMatcher<VarDecl>().match(ToTU, varDecl(hasName("a")));
ASTImporterLookupTable LT(*ToTU);
auto Res = LT.lookup(ToTU, D->getDeclName());
friend void foo(){}
};
)";
- TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
+ TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX03);
auto *X = FirstDeclMatcher<ClassTemplateDecl>().match(
ToTU, classTemplateDecl(hasName("X")));
auto *Foo = FirstDeclMatcher<FunctionDecl>().match(
TEST_P(ASTImporterLookupTableTest,
FwdDeclStructShouldBeFoundByImporterSpecificLookup) {
TranslationUnitDecl *ToTU =
- getToTuDecl("struct A { struct Foo *p; };", Lang_C);
+ getToTuDecl("struct A { struct Foo *p; };", Lang_C99);
auto *Foo =
FirstDeclMatcher<RecordDecl>().match(ToTU, recordDecl(hasName("Foo")));
auto *A =
TEST_P(ASTImporterLookupTableTest, LookupFindsNamesInDifferentDC) {
TranslationUnitDecl *ToTU =
- getToTuDecl("int V; struct A { int V; }; struct B { int V; };", Lang_C);
+ getToTuDecl("int V; struct A { int V; }; struct B { int V; };", Lang_C99);
DeclarationName VName = FirstDeclMatcher<VarDecl>()
.match(ToTU, varDecl(hasName("V")))
->getDeclName();
void foo(int);
void foo(int, int);
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *F0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, functionDecl());
void operator+(X, X);
void operator-(X, X);
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *FPlus = FirstDeclMatcher<FunctionDecl>().match(
struct X {};
void operator+(X, X);
)",
- Lang_CXX);
+ Lang_CXX03);
auto *ToPlus = FirstDeclMatcher<FunctionDecl>().match(
ToTU, functionDecl(hasOverloadedOperatorName("+")));
struct X {};
void operator+(X, X);
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromPlus = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasOverloadedOperatorName("+")));
R"(
class Y { friend class F; };
)",
- Lang_CXX);
+ Lang_CXX03);
// In this case, the CXXRecordDecl is hidden, the FriendDecl is not a parent.
// So we must dig up the underlying CXXRecordDecl.
R"(
class Y { template <class T> friend class F; };
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *F = FirstDeclMatcher<ClassTemplateDecl>().match(
friend class F<T>;
};
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *F = FirstDeclMatcher<ClassTemplateDecl>().match(
friend class F<int>;
};
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *F = FirstDeclMatcher<ClassTemplateDecl>().match(
R"(
class Y { friend void F(); };
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *F =
X<char> xc;
}
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
R"(
class Y { template <class T> friend void F(); };
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *F = FirstDeclMatcher<FunctionTemplateDecl>().match(
friend struct X;
};
)",
- Lang_CXX);
+ Lang_CXX03);
ASTImporterLookupTable LT(*ToTU);
auto *X = FirstDeclMatcher<CXXRecordDecl>().match(
B
};
)",
- Lang_C);
+ Lang_C99);
ASTImporterLookupTable LT(*ToTU);
auto *E = FirstDeclMatcher<EnumDecl>().match(ToTU, enumDecl(hasName("E")));
namespace N {
}
)",
- Lang_CXX);
+ Lang_CXX03);
auto *N1 =
LastDeclMatcher<NamespaceDecl>().match(ToTU, namespaceDecl(hasName("N")));
auto *A = FirstDeclMatcher<VarDecl>().match(ToTU, varDecl(hasName("A")));
};
}
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromFwd = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("X"), unless(isImplicit())));
auto *FromDef = LastDeclMatcher<CXXRecordDecl>().match(
ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
ASSERT_EQ(FromFwd->getCanonicalDecl(), FromDef->getCanonicalDecl());
- auto *ToDef = cast_or_null<CXXRecordDecl>(Import(FromDef, Lang_CXX));
- auto *ToFwd = cast_or_null<CXXRecordDecl>(Import(FromFwd, Lang_CXX));
+ auto *ToDef = cast_or_null<CXXRecordDecl>(Import(FromDef, Lang_CXX03));
+ auto *ToFwd = cast_or_null<CXXRecordDecl>(Import(FromFwd, Lang_CXX03));
EXPECT_NE(ToFwd, ToDef);
EXPECT_FALSE(ToFwd->isThisDeclarationADefinition());
EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
template <typename T> friend void foo();
};
)",
- Lang_CXX);
+ Lang_CXX03);
auto *Friend = FirstDeclMatcher<FunctionTemplateDecl>().match(
ToTU, functionTemplateDecl(hasName("foo")));
R"(
template <typename T> void foo();
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromFoo = FirstDeclMatcher<FunctionTemplateDecl>().match(
FromTU, functionTemplateDecl(hasName("foo")));
- auto *Imported = Import(FromFoo, Lang_CXX);
+ auto *Imported = Import(FromFoo, Lang_CXX03);
EXPECT_EQ(Imported->getPreviousDecl(), Friend);
}
template <>
class X<int> { int a; };
)",
- Lang_CXX);
+ Lang_CXX03);
TranslationUnitDecl *FromTU = getTuDecl(
R"(
template <typename T>
template <>
class X<int> { double b; };
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
FromTU, classTemplateSpecializationDecl(hasName("X")));
- ClassTemplateSpecializationDecl *ImportedSpec = Import(FromSpec, Lang_CXX);
+ ClassTemplateSpecializationDecl *ImportedSpec = Import(FromSpec, Lang_CXX03);
EXPECT_FALSE(ImportedSpec);
// The original Decl is kept, no new decl is created.
TEST_P(ErrorHandlingTest,
ErrorHappensAfterCreatingTheNodeButBeforeLinkingThatToTheAST) {
TranslationUnitDecl *FromTU = getTuDecl(
- std::string("void foo() { ") + ErroneousStmt + " }",
- Lang_CXX);
+ std::string("void foo() { ") + ErroneousStmt + " }", Lang_CXX03);
auto *FromFoo = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("foo")));
- FunctionDecl *ImportedFoo = Import(FromFoo, Lang_CXX);
+ FunctionDecl *ImportedFoo = Import(FromFoo, Lang_CXX03);
EXPECT_FALSE(ImportedFoo);
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
// encountering the error. The error is set for the counterpart of the nodes in
// the "from" context.
TEST_P(ErrorHandlingTest, ErrorHappensAfterNodeIsCreatedAndLinked) {
- TranslationUnitDecl *FromTU = getTuDecl(
- std::string(R"(
+ TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
void f();
void f() { )") + ErroneousStmt + R"( }
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromProto = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
auto *FromDef =
LastDeclMatcher<FunctionDecl>().match(FromTU, functionDecl(hasName("f")));
- FunctionDecl *ImportedProto = Import(FromProto, Lang_CXX);
+ FunctionDecl *ImportedProto = Import(FromProto, Lang_CXX03);
EXPECT_FALSE(ImportedProto); // Could not import.
// However, we created two nodes in the AST. 1) the fwd decl 2) the
// definition. The definition is not added to its DC, but the fwd decl is
// An error should be set for a class if we cannot import one member.
TEST_P(ErrorHandlingTest, ErrorIsPropagatedFromMemberToClass) {
- TranslationUnitDecl *FromTU = getTuDecl(
- std::string(R"(
+ TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
class X {
void f() { )") + ErroneousStmt + R"( } // This member has the error
// during import.
void ok(); // The error should not prevent importing this.
}; // An error will be set for X too.
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("X")));
- CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX);
+ CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
// An error is set for X.
EXPECT_FALSE(ImportedX);
ASSERT_TRUE(OptErr);
EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
// And any subsequent import should fail.
- CXXMethodDecl *ImportedF = Import(FromF, Lang_CXX);
+ CXXMethodDecl *ImportedF = Import(FromF, Lang_CXX03);
EXPECT_FALSE(ImportedF);
// There is an error set for the other member too.
OptErr = Importer->getImportDeclErrorIfAny(FromOK);
EXPECT_TRUE(OptErr);
// Cannot import the other member.
- CXXMethodDecl *ImportedOK = Import(FromOK, Lang_CXX);
+ CXXMethodDecl *ImportedOK = Import(FromOK, Lang_CXX03);
EXPECT_FALSE(ImportedOK);
}
// And to all AST nodes which we visit during the import process which finally
// ends up in a failure (in the error() function).
TEST_P(ErrorHandlingTest, ErrorPropagatesThroughImportCycles) {
- Decl *FromTU = getTuDecl(
- std::string(R"(
+ Decl *FromTU = getTuDecl(std::string(R"(
namespace NS {
class A {
template <int I> class F {};
class X {
template <int I> friend class F;
- void error() { )") + ErroneousStmt + R"( }
+ void error() { )") +
+ ErroneousStmt + R"( }
};
};
class B {};
} // NS
)",
- Lang_CXX, "input0.cc");
+ Lang_CXX03, "input0.cc");
auto *FromFRD = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("F"), isDefinition()));
// Start by importing the templated CXXRecordDecl of F.
// Import fails for that.
- EXPECT_FALSE(Import(FromFRD, Lang_CXX));
+ EXPECT_FALSE(Import(FromFRD, Lang_CXX03));
// Import fails for A.
- EXPECT_FALSE(Import(FromA, Lang_CXX));
+ EXPECT_FALSE(Import(FromA, Lang_CXX03));
// But we should be able to import the independent B.
- EXPECT_TRUE(Import(FromB, Lang_CXX));
+ EXPECT_TRUE(Import(FromB, Lang_CXX03));
// And the namespace.
- EXPECT_TRUE(Import(FromNS, Lang_CXX));
+ EXPECT_TRUE(Import(FromNS, Lang_CXX03));
// An error is set to the templated CXXRecordDecl of F.
ASTImporter *Importer = findFromTU(FromFRD)->Importer.get();
}
TEST_P(ErrorHandlingTest, ErrorIsNotPropagatedFromMemberToNamespace) {
- TranslationUnitDecl *FromTU = getTuDecl(
- std::string(R"(
+ TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
namespace X {
void f() { )") + ErroneousStmt + R"( } // This member has the error
// during import.
void ok(); // The error should not prevent importing this.
}; // An error will be set for X too.
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromX = FirstDeclMatcher<NamespaceDecl>().match(
FromTU, namespaceDecl(hasName("X")));
- NamespaceDecl *ImportedX = Import(FromX, Lang_CXX);
+ NamespaceDecl *ImportedX = Import(FromX, Lang_CXX03);
// There is no error set for X.
EXPECT_TRUE(ImportedX);
ASSERT_TRUE(OptErr);
EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
// And any subsequent import should fail.
- FunctionDecl *ImportedF = Import(FromF, Lang_CXX);
+ FunctionDecl *ImportedF = Import(FromF, Lang_CXX03);
EXPECT_FALSE(ImportedF);
// There is no error set for ok().
OptErr = Importer->getImportDeclErrorIfAny(FromOK);
EXPECT_FALSE(OptErr);
// And we should be able to import.
- FunctionDecl *ImportedOK = Import(FromOK, Lang_CXX);
+ FunctionDecl *ImportedOK = Import(FromOK, Lang_CXX03);
EXPECT_TRUE(ImportedOK);
}
TEST_P(ErrorHandlingTest,
ImportedDeclWithErrorShouldFailTheImportOfDeclWhichMapToIt) {
// We already have a fwd decl.
- TranslationUnitDecl *ToTU = getToTuDecl(
- "class X;", Lang_CXX);
+ TranslationUnitDecl *ToTU = getToTuDecl("class X;", Lang_CXX03);
// Then we import a definition.
{
TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
void ok();
};
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("X")));
- CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX);
+ CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
// An error is set for X ...
EXPECT_FALSE(ImportedX);
void ok();
};
)",
- Lang_CXX, "input1.cc");
+ Lang_CXX03, "input1.cc");
auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("X")));
- CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX);
+ CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
// If we did not save the errors for the "to" context then the below checks
// would fail, because the lookup finds the fwd Decl of the existing
struct Class { };
)";
- TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
- TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX, "input.cc");
+ TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX03);
+ TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX03, "input.cc");
auto *ToClassProto = FirstDeclMatcher<ClassTemplateDecl>().match(
ToTU, classTemplateDecl(hasName("Class")));
ASSERT_EQ(FromClassDef->getMostRecentDecl(), FromClassDef);
ASSERT_EQ(FromClassProto->getMostRecentDecl(), FromClassProto);
- auto *ImportedDef = Import(FromClassDef, Lang_CXX);
+ auto *ImportedDef = Import(FromClassDef, Lang_CXX03);
// At import we should find the definition for 'Class' even if the
// prototype (inside 'friend') for it comes first in the AST and is not
// linked to the definition.
class X{};
};
)",
- Lang_CXX);
+ Lang_CXX03);
auto *ToX = FirstDeclMatcher<CXXRecordDecl>().match(
ToTU, cxxRecordDecl(hasName("X")));
R"(
class X;
)",
- Lang_CXX);
+ Lang_CXX03);
auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
FromTU, cxxRecordDecl(hasName("X")));
- auto *ImportedX = Import(FromX, Lang_CXX);
+ auto *ImportedX = Import(FromX, Lang_CXX03);
// The lookup must find the existing class definition in the LinkageSpecDecl.
// Then the importer renders the existing and the new decl into one chain.
EXPECT_EQ(ImportedX->getCanonicalDecl(), ToX->getCanonicalDecl());
"__SVBool_t"
};
- TranslationUnitDecl *ToTU = getToTuDecl("", Lang_CXX);
- TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX, "input.cc");
+ TranslationUnitDecl *ToTU = getToTuDecl("", Lang_CXX03);
+ TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX03, "input.cc");
for (auto *TypeName : TypeNames) {
auto *ToTypedef = FirstDeclMatcher<TypedefDecl>().match(
ToTU, typedefDecl(hasName(TypeName)));
FromTU, typedefDecl(hasName(TypeName)));
QualType FromType = FromTypedef->getUnderlyingType();
- QualType ImportedType = ImportType(FromType, FromTypedef, Lang_CXX);
+ QualType ImportedType = ImportType(FromType, FromTypedef, Lang_CXX03);
EXPECT_EQ(ImportedType, ToType);
}
}
auto x = []{} = {}; auto x2 = x;
}
)",
- Lang_CXX2a, "input0.cc");
+ Lang_CXX20, "input0.cc");
auto FromF = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
// We have only one lambda class.
DeclCounter<CXXRecordDecl>().match(FromTU, cxxRecordDecl(isLambda())),
1u);
- FunctionDecl *ToF = Import(FromF, Lang_CXX2a);
+ FunctionDecl *ToF = Import(FromF, Lang_CXX20);
EXPECT_TRUE(ToF);
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
// We have only one lambda class after the import.
auto xb = []{} = {};
}
)",
- Lang_CXX2a, "input0.cc");
+ Lang_CXX20, "input0.cc");
auto FromF = FirstDeclMatcher<FunctionDecl>().match(
FromTU, functionDecl(hasName("f")));
// We have two lambda classes.
DeclCounter<CXXRecordDecl>().match(FromTU, cxxRecordDecl(isLambda())),
2u);
- FunctionDecl *ToF = Import(FromF, Lang_CXX2a);
+ FunctionDecl *ToF = Import(FromF, Lang_CXX20);
EXPECT_TRUE(ToF);
TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
// We have two lambda classes after the import.
SourceLocation Location1;
{
auto Pattern = varDecl(hasName("X"));
- Decl *FromTU = getTuDecl("int X;", Lang_C, "input0.c");
+ Decl *FromTU = getTuDecl("int X;", Lang_C99, "input0.c");
auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- Location1 = Import(FromD, Lang_C)->getLocation();
+ Location1 = Import(FromD, Lang_C99)->getLocation();
}
SourceLocation Location2;
{
auto Pattern = varDecl(hasName("Y"));
- Decl *FromTU = getTuDecl("int Y;", Lang_C, "input1.c");
+ Decl *FromTU = getTuDecl("int Y;", Lang_C99, "input1.c");
auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- Location2 = Import(FromD, Lang_C)->getLocation();
+ Location2 = Import(FromD, Lang_C99)->getLocation();
}
SourceManager &ToSM = ToAST->getSourceManager();
std::string Path = "input0.c";
std::string Source = "int X;";
- TranslationUnitDecl *FromTU = getTuDecl(Source, Lang_C, Path);
+ TranslationUnitDecl *FromTU = getTuDecl(Source, Lang_C99, Path);
SourceLocation ImportedLoc;
{
// Import the VarDecl to trigger the importing of the FileID.
auto Pattern = varDecl(hasName("X"));
VarDecl *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- ImportedLoc = Import(FromD, Lang_C)->getLocation();
+ ImportedLoc = Import(FromD, Lang_C99)->getLocation();
}
// Make sure the imported buffer has the original contents.
// Test importing overwritten file buffers.
std::string Path = "input0.c";
- TranslationUnitDecl *FromTU = getTuDecl("int X;", Lang_C, Path);
+ TranslationUnitDecl *FromTU = getTuDecl("int X;", Lang_C99, Path);
// Overwrite the file buffer for our input file with new content.
const std::string Contents = "overwritten contents";
// Import the VarDecl to trigger the importing of the FileID.
auto Pattern = varDecl(hasName("X"));
VarDecl *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
- ImportedLoc = Import(FromD, Lang_C)->getLocation();
+ ImportedLoc = Import(FromD, Lang_C99)->getLocation();
}
// Make sure the imported buffer has the overwritten contents.
TEST_P(ImportWithExternalSource, CompleteRecordBeforeImporting) {
// Create an empty TU.
- TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX, "input.cpp");
+ TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX03, "input.cpp");
// Create and add the test ExternalASTSource.
std::vector<clang::TagDecl *> CompletedTags;
// Do a minimal import of the created class.
EXPECT_EQ(0U, CompletedTags.size());
- Import(Record, Lang_CXX);
+ Import(Record, Lang_CXX03);
EXPECT_EQ(0U, CompletedTags.size());
// Import the definition of the created class.
};
TEST_F(StructuralEquivalenceTest, Int) {
- auto Decls = makeNamedDecls("int foo;", "int foo;", Lang_CXX);
+ auto Decls = makeNamedDecls("int foo;", "int foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls));
}
TEST_F(StructuralEquivalenceTest, IntVsSignedInt) {
- auto Decls = makeNamedDecls("int foo;", "signed int foo;", Lang_CXX);
+ auto Decls = makeNamedDecls("int foo;", "signed int foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls));
}
TEST_F(StructuralEquivalenceTest, Char) {
- auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX);
+ auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls));
}
// This test is disabled for now.
// FIXME Whether this is equivalent is dependendant on the target.
TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) {
- auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX);
+ auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(Decls));
}
TEST_F(StructuralEquivalenceTest, ForwardRecordDecl) {
- auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX);
+ auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls));
}
TEST_F(StructuralEquivalenceTest, IntVsSignedIntInStruct) {
auto Decls = makeNamedDecls("struct foo { int x; };",
- "struct foo { signed int x; };", Lang_CXX);
+ "struct foo { signed int x; };", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(Decls));
}
TEST_F(StructuralEquivalenceTest, CharVsSignedCharInStruct) {
auto Decls = makeNamedDecls("struct foo { char x; };",
- "struct foo { signed char x; };", Lang_CXX);
+ "struct foo { signed char x; };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(Decls));
}
auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
R"(template <class T> struct foo; template<> struct foo<int>{};)",
R"(template <class T> struct foo; template<> struct foo<signed int>{};)",
- Lang_CXX,
- classTemplateSpecializationDecl());
+ Lang_CXX03, classTemplateSpecializationDecl());
auto Spec0 = get<0>(Decls);
auto Spec1 = get<1>(Decls);
EXPECT_TRUE(testStructuralMatch(Spec0, Spec1));
auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
R"(template <class T> struct foo; template<> struct foo<char>{};)",
R"(template <class T> struct foo; template<> struct foo<signed char>{};)",
- Lang_CXX,
- classTemplateSpecializationDecl());
+ Lang_CXX03, classTemplateSpecializationDecl());
auto Spec0 = get<0>(Decls);
auto Spec1 = get<1>(Decls);
EXPECT_FALSE(testStructuralMatch(Spec0, Spec1));
template <class T> struct foo;
template<> struct foo<signed char> : true_type {};
)",
- Lang_CXX,
- classTemplateSpecializationDecl());
+ Lang_CXX03, classTemplateSpecializationDecl());
EXPECT_FALSE(testStructuralMatch(Decls));
}
}
void foo(NS::Derived &);
)";
- auto Decls = makeNamedDecls(Code, Code, Lang_CXX);
+ auto Decls = makeNamedDecls(Code, Code, Lang_CXX03);
NamespaceDecl *NS =
LastDeclMatcher<NamespaceDecl>().match(get<1>(Decls), namespaceDecl());
TEST_F(StructuralEquivalenceTest, WrongOrderOfFieldsInClass) {
auto Code = "class X { int a; int b; };";
- auto Decls = makeNamedDecls(Code, Code, Lang_CXX, "X");
+ auto Decls = makeNamedDecls(Code, Code, Lang_CXX03, "X");
CXXRecordDecl *RD = FirstDeclMatcher<CXXRecordDecl>().match(
get<1>(Decls), cxxRecordDecl(hasName("X")));
};
TEST_F(StructuralEquivalenceFunctionTest, TemplateVsNonTemplate) {
- auto t = makeNamedDecls(
- "void foo();",
- "template<class T> void foo();",
- Lang_CXX);
+ auto t = makeNamedDecls("void foo();", "template<class T> void foo();",
+ Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, DifferentOperators) {
auto t = makeDecls<FunctionDecl>(
- "struct X{}; bool operator<(X, X);",
- "struct X{}; bool operator==(X, X);", Lang_CXX,
- functionDecl(hasOverloadedOperatorName("<")),
+ "struct X{}; bool operator<(X, X);", "struct X{}; bool operator==(X, X);",
+ Lang_CXX03, functionDecl(hasOverloadedOperatorName("<")),
functionDecl(hasOverloadedOperatorName("==")));
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, SameOperators) {
auto t = makeDecls<FunctionDecl>(
- "struct X{}; bool operator<(X, X);",
- "struct X{}; bool operator<(X, X);", Lang_CXX,
- functionDecl(hasOverloadedOperatorName("<")),
+ "struct X{}; bool operator<(X, X);", "struct X{}; bool operator<(X, X);",
+ Lang_CXX03, functionDecl(hasOverloadedOperatorName("<")),
functionDecl(hasOverloadedOperatorName("<")));
EXPECT_TRUE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, CtorVsDtor) {
- auto t = makeDecls<FunctionDecl>(
- "struct X{ X(); };",
- "struct X{ ~X(); };", Lang_CXX,
- cxxConstructorDecl(),
- cxxDestructorDecl());
+ auto t = makeDecls<FunctionDecl>("struct X{ X(); };", "struct X{ ~X(); };",
+ Lang_CXX03, cxxConstructorDecl(),
+ cxxDestructorDecl());
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, ParamConstWithRef) {
- auto t = makeNamedDecls("void foo(int&);",
- "void foo(const int&);", Lang_CXX);
+ auto t =
+ makeNamedDecls("void foo(int&);", "void foo(const int&);", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, ParamConstSimple) {
- auto t = makeNamedDecls("void foo(int);",
- "void foo(const int);", Lang_CXX);
+ auto t = makeNamedDecls("void foo(int);", "void foo(const int);", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(t));
// consider this OK
}
TEST_F(StructuralEquivalenceFunctionTest, Throw) {
- auto t = makeNamedDecls("void foo();",
- "void foo() throw();", Lang_CXX);
+ auto t = makeNamedDecls("void foo();", "void foo() throw();", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceFunctionTest, ReturnType) {
- auto t = makeNamedDecls("char foo();",
- "int foo();", Lang_CXX);
+ auto t = makeNamedDecls("char foo();", "int foo();", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, ReturnConst) {
- auto t = makeNamedDecls("char foo();",
- "const char foo();", Lang_CXX);
+ auto t = makeNamedDecls("char foo();", "const char foo();", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceFunctionTest, ParamCount) {
- auto t = makeNamedDecls("void foo(int);",
- "void foo(int, int);", Lang_CXX);
+ auto t = makeNamedDecls("void foo(int);", "void foo(int, int);", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, ParamType) {
- auto t = makeNamedDecls("void foo(int);",
- "void foo(char);", Lang_CXX);
+ auto t = makeNamedDecls("void foo(int);", "void foo(char);", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, ParamName) {
- auto t = makeNamedDecls("void foo(int a);",
- "void foo(int b);", Lang_CXX);
+ auto t = makeNamedDecls("void foo(int a);", "void foo(int b);", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, Variadic) {
- auto t = makeNamedDecls("void foo(int x...);",
- "void foo(int x);", Lang_CXX);
+ auto t =
+ makeNamedDecls("void foo(int x...);", "void foo(int x);", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, ParamPtr) {
- auto t = makeNamedDecls("void foo(int *);",
- "void foo(int);", Lang_CXX);
+ auto t = makeNamedDecls("void foo(int *);", "void foo(int);", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, NameInParen) {
- auto t = makeNamedDecls(
- "void ((foo))();",
- "void foo();",
- Lang_CXX);
+ auto t = makeNamedDecls("void ((foo))();", "void foo();", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceFunctionTest, FunctionsWithDifferentNoreturnAttr) {
- auto t = makeNamedDecls(
- "__attribute__((noreturn)) void foo();",
- " void foo();",
- Lang_C);
+ auto t = makeNamedDecls("__attribute__((noreturn)) void foo();",
+ " void foo();", Lang_C99);
EXPECT_TRUE(testStructuralMatch(t));
}
if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getArch() !=
llvm::Triple::x86_64)
return;
- auto t = makeNamedDecls(
- "__attribute__((preserve_all)) void foo();",
- "__attribute__((ms_abi)) void foo();",
- Lang_C);
+ auto t = makeNamedDecls("__attribute__((preserve_all)) void foo();",
+ "__attribute__((ms_abi)) void foo();", Lang_C99);
EXPECT_FALSE(testStructuralMatch(t));
}
return;
auto t = makeNamedDecls(
"__attribute__((no_caller_saved_registers)) void foo();",
- " void foo();",
- Lang_C);
+ " void foo();", Lang_C99);
EXPECT_FALSE(testStructuralMatch(t));
}
};
TEST_F(StructuralEquivalenceCXXMethodTest, Virtual) {
- auto t = makeDecls<CXXMethodDecl>(
- "struct X { void foo(); };",
- "struct X { virtual void foo(); };", Lang_CXX,
- cxxMethodDecl(hasName("foo")));
+ auto t = makeDecls<CXXMethodDecl>("struct X { void foo(); };",
+ "struct X { virtual void foo(); };",
+ Lang_CXX03, cxxMethodDecl(hasName("foo")));
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, Pure) {
auto t = makeNamedDecls("struct X { virtual void foo(); };",
- "struct X { virtual void foo() = 0; };", Lang_CXX);
+ "struct X { virtual void foo() = 0; };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, DISABLED_Final) {
// The final-ness is not checked yet.
- auto t = makeNamedDecls("struct X { virtual void foo(); };",
- "struct X { virtual void foo() final; };", Lang_CXX);
+ auto t =
+ makeNamedDecls("struct X { virtual void foo(); };",
+ "struct X { virtual void foo() final; };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, Const) {
auto t = makeNamedDecls("struct X { void foo(); };",
- "struct X { void foo() const; };", Lang_CXX);
+ "struct X { void foo() const; };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, Static) {
auto t = makeNamedDecls("struct X { void foo(); };",
- "struct X { static void foo(); };", Lang_CXX);
+ "struct X { static void foo(); };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceCXXMethodTest, AccessSpecifier) {
- auto t = makeDecls<CXXMethodDecl>(
- "struct X { public: void foo(); };",
- "struct X { private: void foo(); };", Lang_CXX,
- cxxMethodDecl(hasName("foo")));
+ auto t = makeDecls<CXXMethodDecl>("struct X { public: void foo(); };",
+ "struct X { private: void foo(); };",
+ Lang_CXX03, cxxMethodDecl(hasName("foo")));
EXPECT_FALSE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceCXXMethodTest, Constructor) {
- auto t = makeDecls<FunctionDecl>(
- "void foo();", "struct foo { foo(); };", Lang_CXX,
- functionDecl(hasName("foo")), cxxConstructorDecl(hasName("foo")));
+ auto t = makeDecls<FunctionDecl>("void foo();", "struct foo { foo(); };",
+ Lang_CXX03, functionDecl(hasName("foo")),
+ cxxConstructorDecl(hasName("foo")));
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, ConstructorParam) {
auto t = makeDecls<CXXConstructorDecl>("struct X { X(); };",
- "struct X { X(int); };", Lang_CXX,
+ "struct X { X(int); };", Lang_CXX03,
cxxConstructorDecl(hasName("X")));
EXPECT_FALSE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceCXXMethodTest, Operator) {
- auto t = makeDecls<FunctionDecl>(
- "struct X { int operator +(int); };",
- "struct X { int operator -(int); };", Lang_CXX,
- functionDecl(hasOverloadedOperatorName("+")),
- functionDecl(hasOverloadedOperatorName("-")));
+ auto t =
+ makeDecls<FunctionDecl>("struct X { int operator +(int); };",
+ "struct X { int operator -(int); };", Lang_CXX03,
+ functionDecl(hasOverloadedOperatorName("+")),
+ functionDecl(hasOverloadedOperatorName("-")));
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, OutOfClass1) {
auto t = makeDecls<FunctionDecl>(
"struct X { virtual void f(); }; void X::f() { }",
- "struct X { virtual void f() { }; };",
- Lang_CXX,
+ "struct X { virtual void f() { }; };", Lang_CXX03,
functionDecl(allOf(hasName("f"), isDefinition())));
EXPECT_TRUE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceCXXMethodTest, OutOfClass2) {
auto t = makeDecls<FunctionDecl>(
"struct X { virtual void f(); }; void X::f() { }",
- "struct X { void f(); }; void X::f() { }",
- Lang_CXX,
+ "struct X { void f(); }; void X::f() { }", Lang_CXX03,
functionDecl(allOf(hasName("f"), isDefinition())));
EXPECT_FALSE(testStructuralMatch(t));
}
};
TEST_F(StructuralEquivalenceRecordTest, Name) {
- auto t = makeDecls<CXXRecordDecl>(
- "struct A{ };",
- "struct B{ };",
- Lang_CXX,
- cxxRecordDecl(hasName("A")),
- cxxRecordDecl(hasName("B")));
+ auto t = makeDecls<CXXRecordDecl>("struct A{ };", "struct B{ };", Lang_CXX03,
+ cxxRecordDecl(hasName("A")),
+ cxxRecordDecl(hasName("B")));
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceRecordTest, Fields) {
- auto t = makeNamedDecls(
- "struct foo{ int x; };",
- "struct foo{ char x; };",
- Lang_CXX);
+ auto t = makeNamedDecls("struct foo{ int x; };", "struct foo{ char x; };",
+ Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceRecordTest, DISABLED_Methods) {
// Currently, methods of a class are not checked at class equivalence.
- auto t = makeNamedDecls(
- "struct foo{ int x(); };",
- "struct foo{ char x(); };",
- Lang_CXX);
+ auto t = makeNamedDecls("struct foo{ int x(); };", "struct foo{ char x(); };",
+ Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceRecordTest, Bases) {
- auto t = makeNamedDecls(
- "struct A{ }; struct foo: A { };",
- "struct B{ }; struct foo: B { };",
- Lang_CXX);
+ auto t = makeNamedDecls("struct A{ }; struct foo: A { };",
+ "struct B{ }; struct foo: B { };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceRecordTest, InheritanceVirtual) {
- auto t = makeNamedDecls(
- "struct A{ }; struct foo: A { };",
- "struct A{ }; struct foo: virtual A { };",
- Lang_CXX);
+ auto t =
+ makeNamedDecls("struct A{ }; struct foo: A { };",
+ "struct A{ }; struct foo: virtual A { };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceRecordTest, DISABLED_InheritanceType) {
// Access specifier in inheritance is not checked yet.
- auto t = makeNamedDecls(
- "struct A{ }; struct foo: public A { };",
- "struct A{ }; struct foo: private A { };",
- Lang_CXX);
+ auto t =
+ makeNamedDecls("struct A{ }; struct foo: public A { };",
+ "struct A{ }; struct foo: private A { };", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
int a;
};
)";
- auto t = makeNamedDecls(Code, Code, Lang_CXX);
+ auto t = makeNamedDecls(Code, Code, Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(t));
}
} entry1;
};
)",
- "", Lang_C);
+ "", Lang_C99);
auto *TU = get<0>(t);
auto *Entry0 =
FirstDeclMatcher<FieldDecl>().match(TU, fieldDecl(hasName("entry0")));
};
};
)",
- "", Lang_C);
+ "", Lang_C99);
auto *TU = get<0>(t);
auto *A = FirstDeclMatcher<IndirectFieldDecl>().match(
TU, indirectFieldDecl(hasName("a")));
struct { int a; };
};
)",
- Lang_C);
+ Lang_C99);
auto *TU = get<0>(t);
auto *A = FirstDeclMatcher<IndirectFieldDecl>().match(
} entry1;
};
)";
- auto t = makeTuDecls(Code, Code, Lang_C);
+ auto t = makeTuDecls(Code, Code, Lang_C99);
auto *FromTU = get<0>(t);
auto *Entry1 =
}
TEST_F(StructuralEquivalenceRecordTest, TemplateVsNonTemplate) {
- auto t = makeDecls<CXXRecordDecl>(
- "struct A { };",
- "template<class T> struct A { };",
- Lang_CXX,
- cxxRecordDecl(hasName("A")));
+ auto t = makeDecls<CXXRecordDecl>("struct A { };",
+ "template<class T> struct A { };",
+ Lang_CXX03, cxxRecordDecl(hasName("A")));
EXPECT_FALSE(testStructuralMatch(t));
}
}
TEST_F(StructuralEquivalenceTest, CompareSameDeclWithMultiple) {
- auto t = makeNamedDecls(
- "struct A{ }; struct B{ }; void foo(A a, A b);",
- "struct A{ }; struct B{ }; void foo(A a, B b);",
- Lang_CXX);
+ auto t = makeNamedDecls("struct A{ }; struct B{ }; void foo(A a, A b);",
+ "struct A{ }; struct B{ }; void foo(A a, B b);",
+ Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceTest, ExplicitBoolDifferent) {
auto Decls = makeNamedDecls("struct foo {explicit(false) foo(int);};",
- "struct foo {explicit(true) foo(int);};", Lang_CXX2a);
+ "struct foo {explicit(true) foo(int);};", Lang_CXX20);
CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
get<0>(Decls), cxxConstructorDecl(hasName("foo")));
CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
TEST_F(StructuralEquivalenceTest, ExplicitBoolSame) {
auto Decls = makeNamedDecls("struct foo {explicit(true) foo(int);};",
- "struct foo {explicit(true) foo(int);};", Lang_CXX2a);
+ "struct foo {explicit(true) foo(int);};", Lang_CXX20);
CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
get<0>(Decls), cxxConstructorDecl(hasName("foo")));
CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
TEST_F(StructuralEquivalenceTemplateTest, ExactlySameTemplates) {
auto t = makeNamedDecls("template <class T> struct foo;",
- "template <class T> struct foo;", Lang_CXX);
+ "template <class T> struct foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceTemplateTest, DifferentTemplateArgName) {
auto t = makeNamedDecls("template <class T> struct foo;",
- "template <class U> struct foo;", Lang_CXX);
+ "template <class U> struct foo;", Lang_CXX03);
EXPECT_TRUE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceTemplateTest, DifferentTemplateArgKind) {
auto t = makeNamedDecls("template <class T> struct foo;",
- "template <int T> struct foo;", Lang_CXX);
+ "template <int T> struct foo;", Lang_CXX03);
EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceTemplateTest, ExplicitBoolSame) {
- auto Decls = makeNamedDecls("template <bool b> struct foo {explicit(b) foo(int);};",
- "template <bool b> struct foo {explicit(b) foo(int);};", Lang_CXX2a);
+ auto Decls = makeNamedDecls(
+ "template <bool b> struct foo {explicit(b) foo(int);};",
+ "template <bool b> struct foo {explicit(b) foo(int);};", Lang_CXX20);
CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
get<0>(Decls), cxxConstructorDecl(hasName("foo<b>")));
CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
}
TEST_F(StructuralEquivalenceTemplateTest, ExplicitBoolDifference) {
- auto Decls = makeNamedDecls("template <bool b> struct foo {explicit(b) foo(int);};",
- "template <bool b> struct foo {explicit(!b) foo(int);};", Lang_CXX2a);
+ auto Decls = makeNamedDecls(
+ "template <bool b> struct foo {explicit(b) foo(int);};",
+ "template <bool b> struct foo {explicit(!b) foo(int);};", Lang_CXX20);
CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
get<0>(Decls), cxxConstructorDecl(hasName("foo<b>")));
CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
// Instantiate with substitution Arg into P1.
template class Templ <Arg>;
)",
- Lang_CXX, classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_TRUE(testStructuralMatch(t));
}
// Instantiate with substitution Arg into P1.
template class Templ <Arg>;
)",
- Lang_CXX, classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_FALSE(testStructuralMatch(t));
}
void f();
};
)",
- Lang_CXX,
+ Lang_CXX03,
functionTemplateDecl(hasName("f")));
EXPECT_FALSE(testStructuralMatch(t));
}
void f();
};
)",
- Lang_CXX,
+ Lang_CXX03,
functionTemplateDecl(hasName("f")));
EXPECT_FALSE(testStructuralMatch(t));
}
// Explicit instantiation with UNqualified name.
template struct Primary<Arg>;
)",
- Lang_CXX,
- classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_TRUE(testStructuralMatch(t));
}
// Explicit instantiation with UNqualified name.
template struct Primary<Arg>;
)",
- Lang_CXX,
- classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_FALSE(testStructuralMatch(t));
}
// Explicit instantiation with UNqualified name.
template struct Primary<Arg>;
)",
- Lang_CXX,
- classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_TRUE(testStructuralMatch(t));
}
// Explicit instantiation with UNqualified name.
template struct Primary<Arg>;
)",
- Lang_CXX,
- classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_FALSE(testStructuralMatch(t));
}
template struct Primary<Arg>;
}
)",
- Lang_CXX,
- classTemplateSpecializationDecl(hasName("Primary")));
+ Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
EXPECT_FALSE(testStructuralMatch(t));
}
struct StructuralEquivalenceCacheTest : public StructuralEquivalenceTest {
class B {};
void x(A, B);
)",
- Lang_CXX);
+ Lang_CXX03);
StructuralEquivalenceContext Ctx(
get<0>(TU)->getASTContext(), get<1>(TU)->getASTContext(),
friend void y(B *);
};
)",
- Lang_CXX);
+ Lang_CXX03);
StructuralEquivalenceContext Ctx(
get<0>(TU)->getASTContext(), get<1>(TU)->getASTContext(),
friend void x(A *);
};
)",
- Lang_CXX);
+ Lang_CXX03);
StructuralEquivalenceContext Ctx(
get<0>(TU)->getASTContext(), get<1>(TU)->getASTContext(),