This is an archive of the discontinued LLVM Phabricator instance.

Differential D57236

[ASTImporter] Unify redecl chain tests as type parameterized tests
ClosedPublic

Authored by martong on Jan 25 2019, 6:03 AM.

Details

Reviewers
a_sidorin
shafik
a.sidorin
Commits
rC354259: [ASTImporter] Unify redecl chain tests as type parameterized tests
rGfc03fc6e6919: [ASTImporter] Unify redecl chain tests as type parameterized tests
rL354259: [ASTImporter] Unify redecl chain tests as type parameterized tests
Summary

This patch unifies all those tests which check the correctness of the
redecl chains. Previously we had several structurally very similar test
cases for each language construct (class, function, variable, function
template, ...).

We still use value-parameterized tests for the different AST
compatibility switches (-fdelayed-template-parsing, -fms-compatibility).
Gtest makes it possible to have either value-parameterized or
type-parameterized fixtures. However, we cannot have both value- and
type-parameterized test fixtures. So we use a value-parameterized test
fixture in the gtest sense. We intend to mimic gtest's type-parameters
via the type template parameter. We manually instantiate the different
tests with the each types.

After this patch I am planning to put the "generic redecl chain" related
tests into their own separate test file (in another patch).

Diff Detail

Event Timeline

martong created this revision.Jan 25 2019, 6:03 AM
Herald added a reviewer: a.sidorin. · View Herald TranscriptJan 25 2019, 6:03 AM
Herald added subscribers: cfe-commits, gamesh411, Szelethus and 2 others. · View Herald Transcript
Harbormaster completed remote builds in B27306: Diff 183527.Jan 25 2019, 6:03 AM
martong added a comment.Feb 1 2019, 5:01 AM

Ping

Herald added a project: Restricted Project. · View Herald TranscriptFeb 1 2019, 5:01 AM
martong added a comment.Feb 11 2019, 2:25 AM

Ping.
Please raise your objections if you have any until the 18th of February (that date I am going to commit if there are no objections). Also, please let me know if you find this deadline too strict.

a_sidorin added a comment.Feb 11 2019, 3:58 PM

Hi Gabor,

The refactoring looks great. I have some minor comments inline.

unittests/AST/ASTImporterTest.cpp
3552

I would ask you not to use numbers when possible: these names are hard to keep in mind. There can be a nice naming scheme like "FromTUDef/FromTUProto/FromTUProtoDef|, I think it would be much better.

3707

Is it possible to disable the tests instead of commenting them out?

martong updated this revision to Diff 186445.Feb 12 2019, 6:00 AM
  • Remove numbers when possible
  • Use disabled tests instead of commented out tests
Herald added a subscriber: jdoerfert. · View Herald TranscriptFeb 12 2019, 6:00 AM
Harbormaster completed remote builds in B28049: Diff 186445.Feb 12 2019, 6:01 AM
martong marked 4 inline comments as done.Feb 12 2019, 6:03 AM

Thanks for the review Alexei!

unittests/AST/ASTImporterTest.cpp
3552

Ok. I have removed the numbers where it makes sense: where we have a proto and a definition. However, there are cases when we import two similar nodes (e.g. two prototypes) then I think the numbering is needed to identify the first and second node.

3707

Okay, I have changed the macro so we can disable the tests.

a_sidorin accepted this revision.Feb 16 2019, 1:54 AM

Thanks for the changes! The patch looks completely fine to me now.

This revision is now accepted and ready to land.Feb 16 2019, 1:54 AM
martong updated this revision to Diff 187206.Feb 18 2019, 3:02 AM
martong marked 2 inline comments as done.

Rebase to master

Harbormaster completed remote builds in B28245: Diff 187206.Feb 18 2019, 3:06 AM
Closed by commit rL354259: [ASTImporter] Unify redecl chain tests as type parameterized tests (authored by martong). · Explain WhyFeb 18 2019, 3:09 AM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 18 2019, 3:09 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript

Revision Contents

PathSize
unittests/
AST/
1208 lines

Diff 186445

unittests/AST/ASTImporterTest.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines ArgVector getArgVectorForLanguage(Language Lang) const {
for (const auto &Arg : ExtraArgs) { for (const auto &Arg : ExtraArgs) {
Args.push_back(Arg); Args.push_back(Arg);
} }
return Args; return Args;
} }
}; };
auto DefaultTestValuesForRunOptions = ::testing::Values(
ArgVector(), ArgVector{"-fdelayed-template-parsing"},
ArgVector{"-fms-compatibility"},
ArgVector{"-fdelayed-template-parsing", "-fms-compatibility"});
// Base class for those tests which use the family of `testImport` functions. // Base class for those tests which use the family of `testImport` functions.
class TestImportBase : public ParameterizedTestsFixture { class TestImportBase : public ParameterizedTestsFixture {
template <typename NodeType> template <typename NodeType>
NodeType importNode(ASTUnit *From, ASTUnit *To, ASTImporter &Importer, NodeType importNode(ASTUnit *From, ASTUnit *To, ASTImporter &Importer,
NodeType Node) { NodeType Node) {
ASTContext &ToCtx = To->getASTContext(); ASTContext &ToCtx = To->getASTContext();
▲ Show 20 Lines • Show All 1,887 Lines • ▼ Show 20 LinesTEST_P(ASTImporterTestBase, ReimportWithUsedFlag) {
auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX)); auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX));
EXPECT_EQ(Imported1, Imported2); EXPECT_EQ(Imported1, Imported2);
EXPECT_TRUE(Imported2->isUsed(false)); EXPECT_TRUE(Imported2->isUsed(false));
} }
struct ImportFunctions : ASTImporterTestBase {}; struct ImportFunctions : ASTImporterTestBase {};
TEST_P(ImportFunctions,
DefinitionShouldBeImportedAsDefintionWhenThereIsAPrototype) {
Decl *FromTU = getTuDecl("void f(); void f() {}", Lang_CXX);
auto Pattern = functionDecl(hasName("f"));
FunctionDecl *FromD = // Definition
LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
EXPECT_TRUE(cast<FunctionDecl>(ImportedD)->doesThisDeclarationHaveABody());
}
TEST_P(ImportFunctions, DefinitionShouldBeImportedAsADefinition) {
Decl *FromTU = getTuDecl("void f() {}", Lang_CXX);
auto Pattern = functionDecl(hasName("f"));
FunctionDecl *FromD =
FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 1u);
EXPECT_TRUE(cast<FunctionDecl>(ImportedD)->doesThisDeclarationHaveABody());
}
TEST_P(ImportFunctions, ImportPrototypeOfRecursiveFunction) { TEST_P(ImportFunctions, ImportPrototypeOfRecursiveFunction) {
Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX); Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX);
auto Pattern = functionDecl(hasName("f")); auto Pattern = functionDecl(hasName("f"));
auto *From = auto *From =
FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern); // Proto FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern); // Proto
Decl *ImportedD = Import(From, Lang_CXX); Decl *ImportedD = Import(From, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl(); Decl *ToTU = ImportedD->getTranslationUnitDecl();
Show All 20 LinesTEST_P(ImportFunctions, ImportDefinitionOfRecursiveFunction) {
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern); auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern); auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To1); EXPECT_TRUE(ImportedD == To1);
EXPECT_FALSE(To0->doesThisDeclarationHaveABody()); EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
EXPECT_TRUE(To1->doesThisDeclarationHaveABody()); EXPECT_TRUE(To1->doesThisDeclarationHaveABody());
EXPECT_EQ(To1->getPreviousDecl(), To0); EXPECT_EQ(To1->getPreviousDecl(), To0);
} }
TEST_P(ImportFunctions, ImportPrototypes) {
auto Pattern = functionDecl(hasName("f"));
Decl *ImportedD;
{
Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
EXPECT_FALSE(To1->doesThisDeclarationHaveABody());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ImportFunctions, ImportDefinitions) {
auto Pattern = functionDecl(hasName("f"));
Decl *ImportedD;
{
Decl *FromTU = getTuDecl("void f(){}", Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl("void f(){};", Lang_CXX, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 1u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(To0->doesThisDeclarationHaveABody());
}
TEST_P(ImportFunctions, ImportDefinitionThenPrototype) {
auto Pattern = functionDecl(hasName("f"));
Decl *ImportedD;
{
Decl *FromTU = getTuDecl("void f(){}", Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(To0->doesThisDeclarationHaveABody());
EXPECT_FALSE(To1->doesThisDeclarationHaveABody());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ImportFunctions, ImportPrototypeThenDefinition) {
auto Pattern = functionDecl(hasName("f"));
{
Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input0.cc");
FunctionDecl *FromD =
FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl("void f(){}", Lang_CXX, "input1.cc");
FunctionDecl *FromD =
FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
FunctionDecl *ProtoD = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_FALSE(ProtoD->doesThisDeclarationHaveABody());
FunctionDecl *DefinitionD =
LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(DefinitionD->doesThisDeclarationHaveABody());
EXPECT_EQ(DefinitionD->getPreviousDecl(), ProtoD);
}
TEST_P(ImportFunctions, ImportPrototypeThenProtoAndDefinition) {
auto Pattern = functionDecl(hasName("f"));
{
Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl("void f(); void f(){}", Lang_CXX, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 3u);
FunctionDecl *ProtoD = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_FALSE(ProtoD->doesThisDeclarationHaveABody());
FunctionDecl *DefinitionD =
LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(DefinitionD->doesThisDeclarationHaveABody());
EXPECT_TRUE(DefinitionD->getPreviousDecl());
EXPECT_FALSE(DefinitionD->getPreviousDecl()->doesThisDeclarationHaveABody());
EXPECT_EQ(DefinitionD->getPreviousDecl()->getPreviousDecl(), ProtoD);
}
TEST_P(ImportFunctions, OverriddenMethodsShouldBeImported) { TEST_P(ImportFunctions, OverriddenMethodsShouldBeImported) {
auto Code = auto Code =
R"( R"(
struct B { virtual void f(); }; struct B { virtual void f(); };
void B::f() {} void B::f() {}
struct D : B { void f(); }; struct D : B { void f(); };
)"; )";
auto Pattern = auto Pattern =
▲ Show 20 Lines • Show All 1,184 Lines • ▼ Show 20 LinesTEST_P(ImportVariables, InitAndDefinitionAreInTheFromContext) {
auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11)); auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
EXPECT_TRUE(ImportedD->getAnyInitializer()); EXPECT_TRUE(ImportedD->getAnyInitializer());
EXPECT_TRUE(ImportedD->getDefinition()); EXPECT_TRUE(ImportedD->getDefinition());
} }
struct ImportClasses : ASTImporterTestBase {}; struct ImportClasses : ASTImporterTestBase {};
TEST_P(ImportClasses,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition) {
Decl *FromTU = getTuDecl("class X;", Lang_CXX);
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto FromD = FirstDeclMatcher<CXXRecordDecl>().match(FromTU, Pattern);
Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 1u);
auto ToD = LastDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == ToD);
EXPECT_FALSE(ToD->isThisDeclarationADefinition());
}
TEST_P(ImportClasses, ImportPrototypeAfterImportedPrototype) {
Decl *FromTU = getTuDecl("class X; class X;", Lang_CXX);
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto From0 = FirstDeclMatcher<CXXRecordDecl>().match(FromTU, Pattern);
auto From1 = LastDeclMatcher<CXXRecordDecl>().match(FromTU, Pattern);
Decl *Imported0 = Import(From0, Lang_CXX);
Decl *Imported1 = Import(From1, Lang_CXX);
Decl *ToTU = Imported0->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 2u);
auto To0 = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
auto To1 = LastDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(Imported0 == To0);
EXPECT_TRUE(Imported1 == To1);
EXPECT_FALSE(To0->isThisDeclarationADefinition());
EXPECT_FALSE(To1->isThisDeclarationADefinition());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ImportClasses, DefinitionShouldBeImportedAsADefinition) {
Decl *FromTU = getTuDecl("class X {};", Lang_CXX);
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto *FromD = FirstDeclMatcher<CXXRecordDecl>().match(FromTU, Pattern);
Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 1u);
EXPECT_TRUE(cast<CXXRecordDecl>(ImportedD)->isThisDeclarationADefinition());
}
TEST_P(ImportClasses, ImportPrototypeFromDifferentTUAfterImportedPrototype) {
Decl *FromTU0 = getTuDecl("class X;", Lang_CXX, "input0.cc");
Decl *FromTU1 = getTuDecl("class X;", Lang_CXX, "input1.cc");
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto From0 = FirstDeclMatcher<CXXRecordDecl>().match(FromTU0, Pattern);
auto From1 = FirstDeclMatcher<CXXRecordDecl>().match(FromTU1, Pattern);
Decl *Imported0 = Import(From0, Lang_CXX);
Decl *Imported1 = Import(From1, Lang_CXX);
Decl *ToTU = Imported0->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 2u);
auto To0 = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
auto To1 = LastDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(Imported0 == To0);
EXPECT_TRUE(Imported1 == To1);
EXPECT_FALSE(To0->isThisDeclarationADefinition());
EXPECT_FALSE(To1->isThisDeclarationADefinition());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ImportClasses, ImportDefinitions) {
Decl *FromTU0 = getTuDecl("class X {};", Lang_CXX, "input0.cc");
Decl *FromTU1 = getTuDecl("class X {};", Lang_CXX, "input1.cc");
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto From0 = FirstDeclMatcher<CXXRecordDecl>().match(FromTU0, Pattern);
auto From1 = FirstDeclMatcher<CXXRecordDecl>().match(FromTU1, Pattern);
Decl *Imported0 = Import(From0, Lang_CXX);
Decl *Imported1 = Import(From1, Lang_CXX);
Decl *ToTU = Imported0->getTranslationUnitDecl();
EXPECT_EQ(Imported0, Imported1);
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 1u);
auto To0 = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(Imported0 == To0);
EXPECT_TRUE(To0->isThisDeclarationADefinition());
}
TEST_P(ImportClasses, ImportDefinitionThenPrototype) {
Decl *FromTU0 = getTuDecl("class X {};", Lang_CXX, "input0.cc");
Decl *FromTU1 = getTuDecl("class X;", Lang_CXX, "input1.cc");
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto FromDef = FirstDeclMatcher<CXXRecordDecl>().match(FromTU0, Pattern);
auto FromProto = FirstDeclMatcher<CXXRecordDecl>().match(FromTU1, Pattern);
Decl *ImportedDef = Import(FromDef, Lang_CXX);
Decl *ImportedProto = Import(FromProto, Lang_CXX);
Decl *ToTU = ImportedDef->getTranslationUnitDecl();
EXPECT_NE(ImportedDef, ImportedProto);
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 2u);
auto ToDef = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
auto ToProto = LastDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ImportedProto == ToProto);
EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToProto->getPreviousDecl(), ToDef);
}
TEST_P(ImportClasses, ImportPrototypeThenDefinition) {
Decl *FromTU0 = getTuDecl("class X;", Lang_CXX, "input0.cc");
Decl *FromTU1 = getTuDecl("class X {};", Lang_CXX, "input1.cc");
auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
auto FromProto = FirstDeclMatcher<CXXRecordDecl>().match(FromTU0, Pattern);
auto FromDef = FirstDeclMatcher<CXXRecordDecl>().match(FromTU1, Pattern);
Decl *ImportedProto = Import(FromProto, Lang_CXX);
Decl *ImportedDef = Import(FromDef, Lang_CXX);
Decl *ToTU = ImportedDef->getTranslationUnitDecl();
EXPECT_NE(ImportedDef, ImportedProto);
EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, Pattern), 2u);
auto ToProto = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
auto ToDef = LastDeclMatcher<CXXRecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ImportedProto == ToProto);
EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
}
TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInToContext) {
Decl *ToTU = getToTuDecl("struct X;", Lang_C);
Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "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);
EXPECT_NE(ImportedDef, ToProto);
EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
}
TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContext) { TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContext) {
Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C); Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C);
Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "input1.cc"); Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "input1.cc");
auto Pattern = recordDecl(hasName("X"), unless(isImplicit())); auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern); auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern); auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
Decl *ImportedDef = Import(FromDef, Lang_C); Decl *ImportedDef = Import(FromDef, Lang_C);
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 LinesTEST_P(ImportClasses, ImportNestedPrototypeThenDefinition) {
auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern); auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedDef == ToDef); EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ImportedProto == ToProto); EXPECT_TRUE(ImportedProto == ToProto);
EXPECT_TRUE(ToDef->isThisDeclarationADefinition()); EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition()); EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToDef->getPreviousDecl(), ToProto); EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
} }
struct ImportClassTemplates : ASTImporterTestBase {}; // FIXME put these structs and the tests rely on them into their own separate
// test file!
struct Function {
using DeclTy = FunctionDecl;
static constexpr auto *Prototype = "void X();";
static constexpr auto *Definition = "void X() {}";
BindableMatcher<Decl> getPattern() {
return functionDecl(hasName("X"), unless(isImplicit()));
}
};
struct Class {
using DeclTy = CXXRecordDecl;
static constexpr auto *Prototype = "class X;";
static constexpr auto *Definition = "class X {};";
BindableMatcher<Decl> getPattern() {
return cxxRecordDecl(hasName("X"), unless(isImplicit()));
}
};
struct Variable {
using DeclTy = VarDecl;
static constexpr auto *Prototype = "extern int X;";
static constexpr auto *Definition = "int X;";
BindableMatcher<Decl> getPattern() {
return varDecl(hasName("X"));
}
};
struct FunctionTemplate {
using DeclTy = FunctionTemplateDecl;
static constexpr auto *Prototype = "template <class T> void X();";
static constexpr auto *Definition =
R"(
template <class T> void X() {};
// Explicit instantiation is a must because of -fdelayed-template-parsing:
template void X<int>();
)";
BindableMatcher<Decl> getPattern() {
return functionTemplateDecl(hasName("X"), unless(isImplicit()));
}
};
struct ClassTemplate {
using DeclTy = ClassTemplateDecl;
static constexpr auto *Prototype = "template <class T> class X;";
static constexpr auto *Definition = "template <class T> class X {};";
BindableMatcher<Decl> getPattern() {
return classTemplateDecl(hasName("X"), unless(isImplicit()));
}
};
struct FunctionTemplateSpec {
using DeclTy = FunctionDecl;
static constexpr auto *Prototype =
R"(
// Proto of the primary template.
template <class T>
void X();
// Proto of the specialization.
template <>
void X<int>();
)";
static constexpr auto *Definition =
R"(
// Proto of the primary template.
template <class T>
void X();
// Specialization and definition.
template <>
void X<int>() {}
)";
BindableMatcher<Decl> getPattern() {
return functionDecl(hasName("X"), isExplicitTemplateSpecialization());
}
};
template <typename TypeParam>
struct RedeclChain : ASTImporterTestBase {
TEST_P(ImportClassTemplates, using DeclTy = typename TypeParam::DeclTy;
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition) { std::string getPrototype() { return TypeParam::Prototype; }
Decl *FromTU = getTuDecl("template <class T> class X;", Lang_CXX); std::string getDefinition() { return TypeParam::Definition; }
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); BindableMatcher<Decl> getPattern() const { return TypeParam().getPattern(); }
auto FromD = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, Pattern);
void
TypedTest_PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition() {
Decl *FromTU = getTuDecl(getPrototype(), Lang_CXX);
auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
ASSERT_FALSE(FromD->isThisDeclarationADefinition());
Decl *ImportedD = Import(FromD, Lang_CXX); Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl(); Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 1u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
auto ToD = LastDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *ToD = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(ImportedD == ToD); EXPECT_TRUE(ImportedD == ToD);
ASSERT_TRUE(ToD->getTemplatedDecl());
EXPECT_FALSE(ToD->isThisDeclarationADefinition()); EXPECT_FALSE(ToD->isThisDeclarationADefinition());
if (auto *ToT = dyn_cast<TemplateDecl>(ToD))
EXPECT_TRUE(ToT->getTemplatedDecl());
}
void TypedTest_DefinitionShouldBeImportedAsADefinition() {
Decl *FromTU = getTuDecl(getDefinition(), Lang_CXX);
auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
ASSERT_TRUE(FromD->isThisDeclarationADefinition());
Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
auto *ToD = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(ToD->isThisDeclarationADefinition());
if (auto *ToT = dyn_cast<TemplateDecl>(ToD))
EXPECT_TRUE(ToT->getTemplatedDecl());
} }
TEST_P(ImportClassTemplates, ImportPrototypeAfterImportedPrototype) { void TypedTest_ImportPrototypeAfterImportedPrototype() {
Decl *FromTU = getTuDecl( Decl *FromTU = getTuDecl(
"template <class T> class X; template <class T> class X;", Lang_CXX); getPrototype() + getPrototype(), Lang_CXX);
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); auto *From0 =
auto From0 = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, Pattern); FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
auto From1 = LastDeclMatcher<ClassTemplateDecl>().match(FromTU, Pattern); auto *From1 = LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
ASSERT_FALSE(From0->isThisDeclarationADefinition());
ASSERT_FALSE(From1->isThisDeclarationADefinition());
Decl *Imported0 = Import(From0, Lang_CXX); Decl *Imported0 = Import(From0, Lang_CXX);
Decl *Imported1 = Import(From1, Lang_CXX); Decl *Imported1 = Import(From1, Lang_CXX);
Decl *ToTU = Imported0->getTranslationUnitDecl(); Decl *ToTU = Imported0->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 2u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
auto To0 = FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *To0 = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
auto To1 = LastDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *To1 = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(Imported0 == To0); EXPECT_TRUE(Imported0 == To0);
EXPECT_TRUE(Imported1 == To1); EXPECT_TRUE(Imported1 == To1);
ASSERT_TRUE(To0->getTemplatedDecl());
ASSERT_TRUE(To1->getTemplatedDecl());
EXPECT_FALSE(To0->isThisDeclarationADefinition()); EXPECT_FALSE(To0->isThisDeclarationADefinition());
EXPECT_FALSE(To1->isThisDeclarationADefinition()); EXPECT_FALSE(To1->isThisDeclarationADefinition());
EXPECT_EQ(To1->getPreviousDecl(), To0); EXPECT_EQ(To1->getPreviousDecl(), To0);
EXPECT_EQ(To1->getTemplatedDecl()->getPreviousDecl(), if (auto *ToT0 = dyn_cast<TemplateDecl>(To0)) {
To0->getTemplatedDecl()); auto *ToT1 = cast<TemplateDecl>(To1);
ASSERT_TRUE(ToT0->getTemplatedDecl());
ASSERT_TRUE(ToT1->getTemplatedDecl());
EXPECT_EQ(ToT1->getTemplatedDecl()->getPreviousDecl(),
ToT0->getTemplatedDecl());
}
} }
TEST_P(ImportClassTemplates, DefinitionShouldBeImportedAsADefinition) { void TypedTest_ImportDefinitionAfterImportedPrototype() {
Decl *FromTU = getTuDecl("template <class T> class X {};", Lang_CXX); Decl *FromTU = getTuDecl(
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); getPrototype() + getDefinition(), Lang_CXX);
auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, Pattern); auto *FromProto = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
auto *FromDef = LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
Decl *ImportedD = Import(FromD, Lang_CXX); Decl *ImportedProto = Import(FromProto, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl(); Decl *ImportedDef = Import(FromDef, Lang_CXX);
Decl *ToTU = ImportedProto->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 1u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
auto ToD = LastDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *ToProto = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
ASSERT_TRUE(ToD->getTemplatedDecl()); auto *ToDef = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(ToD->isThisDeclarationADefinition()); EXPECT_TRUE(ImportedProto == ToProto);
EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
if (auto *ToProtoT = dyn_cast<TemplateDecl>(ToProto)) {
auto *ToDefT = cast<TemplateDecl>(ToDef);
ASSERT_TRUE(ToProtoT->getTemplatedDecl());
ASSERT_TRUE(ToDefT->getTemplatedDecl());
EXPECT_EQ(ToDefT->getTemplatedDecl()->getPreviousDecl(),
ToProtoT->getTemplatedDecl());
}
} }
TEST_P(ImportClassTemplates, void TypedTest_ImportPrototypeAfterImportedDefinition() {
ImportPrototypeFromDifferentTUAfterImportedPrototype) { Decl *FromTU = getTuDecl(
Decl *FromTU0 = getDefinition() + getPrototype(), Lang_CXX);
getTuDecl("template <class T> class X;", Lang_CXX, "input0.cc"); auto *FromDef = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
Decl *FromTU1 = auto *FromProto = LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
getTuDecl("template <class T> class X;", Lang_CXX, "input1.cc"); ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
auto From0 = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU0, Pattern);
auto From1 = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU1, Pattern); Decl *ImportedDef = Import(FromDef, Lang_CXX);
Decl *ImportedProto = Import(FromProto, Lang_CXX);
Decl *ToTU = ImportedDef->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
auto *ToDef = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
auto *ToProto = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ImportedProto == ToProto);
EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToProto->getPreviousDecl(), ToDef);
if (auto *ToDefT = dyn_cast<TemplateDecl>(ToDef)) {
auto *ToProtoT = cast<TemplateDecl>(ToProto);
ASSERT_TRUE(ToDefT->getTemplatedDecl());
ASSERT_TRUE(ToProtoT->getTemplatedDecl());
EXPECT_EQ(ToProtoT->getTemplatedDecl()->getPreviousDecl(),
ToDefT->getTemplatedDecl());
}
}
void TypedTest_ImportPrototypes() {
Decl *FromTU0 = getTuDecl(getPrototype(), Lang_CXX, "input0.cc");
Decl *FromTU1 = getTuDecl(getPrototype(), Lang_CXX, "input1.cc");
auto *From0 = FirstDeclMatcher<DeclTy>().match(FromTU0, getPattern());
auto *From1 = FirstDeclMatcher<DeclTy>().match(FromTU1, getPattern());
ASSERT_FALSE(From0->isThisDeclarationADefinition());
ASSERT_FALSE(From1->isThisDeclarationADefinition());
Decl *Imported0 = Import(From0, Lang_CXX); Decl *Imported0 = Import(From0, Lang_CXX);
Decl *Imported1 = Import(From1, Lang_CXX); Decl *Imported1 = Import(From1, Lang_CXX);
Decl *ToTU = Imported0->getTranslationUnitDecl(); Decl *ToTU = Imported0->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 2u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
auto To0 = FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *To0 = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
auto To1 = LastDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *To1 = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(Imported0 == To0); EXPECT_TRUE(Imported0 == To0);
EXPECT_TRUE(Imported1 == To1); EXPECT_TRUE(Imported1 == To1);
ASSERT_TRUE(To0->getTemplatedDecl());
ASSERT_TRUE(To1->getTemplatedDecl());
EXPECT_FALSE(To0->isThisDeclarationADefinition()); EXPECT_FALSE(To0->isThisDeclarationADefinition());
EXPECT_FALSE(To1->isThisDeclarationADefinition()); EXPECT_FALSE(To1->isThisDeclarationADefinition());
EXPECT_EQ(To1->getPreviousDecl(), To0); EXPECT_EQ(To1->getPreviousDecl(), To0);
EXPECT_EQ(To1->getTemplatedDecl()->getPreviousDecl(), if (auto *ToT0 = dyn_cast<TemplateDecl>(To0)) {
To0->getTemplatedDecl()); auto *ToT1 = cast<TemplateDecl>(To1);
ASSERT_TRUE(ToT0->getTemplatedDecl());
ASSERT_TRUE(ToT1->getTemplatedDecl());
EXPECT_EQ(ToT1->getTemplatedDecl()->getPreviousDecl(),
ToT0->getTemplatedDecl());
}
// Extra check for specializations.
// FIXME Add this check to other tests too (possibly factor out into a
// function), when they start to pass.
if (auto *From0F = dyn_cast<FunctionDecl>(From0)) {
auto *To0F = cast<FunctionDecl>(To0);
if (From0F->getTemplatedKind() ==
FunctionDecl::TK_FunctionTemplateSpecialization) {
auto *TemplateD = FirstDeclMatcher<FunctionTemplateDecl>().match(
ToTU, functionTemplateDecl());
auto *FirstSpecD = *(TemplateD->spec_begin());
EXPECT_EQ(FirstSpecD->getCanonicalDecl(), To0F->getCanonicalDecl());
}
}
} }
TEST_P(ImportClassTemplates, ImportDefinitions) { void TypedTest_ImportDefinitions() {
Decl *FromTU0 = Decl *FromTU0 = getTuDecl(getDefinition(), Lang_CXX, "input0.cc");
getTuDecl("template <class T> class X {};", Lang_CXX, "input0.cc"); Decl *FromTU1 = getTuDecl(getDefinition(), Lang_CXX, "input1.cc");
Decl *FromTU1 = auto *From0 = FirstDeclMatcher<DeclTy>().match(FromTU0, getPattern());
getTuDecl("template <class T> class X {};", Lang_CXX, "input1.cc"); auto *From1 = FirstDeclMatcher<DeclTy>().match(FromTU1, getPattern());
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); ASSERT_TRUE(From0->isThisDeclarationADefinition());
auto From0 = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU0, Pattern); ASSERT_TRUE(From1->isThisDeclarationADefinition());
auto From1 = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU1, Pattern);
Decl *Imported0 = Import(From0, Lang_CXX); Decl *Imported0 = Import(From0, Lang_CXX);
Decl *Imported1 = Import(From1, Lang_CXX); Decl *Imported1 = Import(From1, Lang_CXX);
Decl *ToTU = Imported0->getTranslationUnitDecl(); Decl *ToTU = Imported0->getTranslationUnitDecl();
EXPECT_EQ(Imported0, Imported1); EXPECT_EQ(Imported0, Imported1);
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 1u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
auto To0 = FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *To0 = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(Imported0 == To0); EXPECT_TRUE(Imported0 == To0);
ASSERT_TRUE(To0->getTemplatedDecl());
EXPECT_TRUE(To0->isThisDeclarationADefinition()); EXPECT_TRUE(To0->isThisDeclarationADefinition());
if (auto *ToT0 = dyn_cast<TemplateDecl>(To0))
EXPECT_TRUE(ToT0->getTemplatedDecl());
} }
TEST_P(ImportClassTemplates, ImportDefinitionThenPrototype) { void TypedTest_ImportDefinitionThenPrototype() {
Decl *FromTU0 = Decl *FromTUDef = getTuDecl(getDefinition(), Lang_CXX, "input0.cc");
getTuDecl("template <class T> class X {};", Lang_CXX, "input0.cc"); Decl *FromTUProto = getTuDecl(getPrototype(), Lang_CXX, "input1.cc");
Decl *FromTU1 = auto *FromDef = FirstDeclMatcher<DeclTy>().match(FromTUDef, getPattern());
getTuDecl("template <class T> class X;", Lang_CXX, "input1.cc"); auto *FromProto =
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); FirstDeclMatcher<DeclTy>().match(FromTUProto, getPattern());
auto FromDef = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU0, Pattern); ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
a_sidorinUnsubmitted
Done
ReplyInline Actions

I would ask you not to use numbers when possible: these names are hard to keep in mind. There can be a nice naming scheme like "FromTUDef/FromTUProto/FromTUProtoDef|, I think it would be much better.

a_sidorin: I would ask you not to use numbers when possible: these names are hard to keep in mind. There…
martongAuthorUnsubmitted
Done
ReplyInline Actions

Ok. I have removed the numbers where it makes sense: where we have a proto and a definition. However, there are cases when we import two similar nodes (e.g. two prototypes) then I think the numbering is needed to identify the first and second node.

martong: Ok. I have removed the numbers where it makes sense: where we have a proto and a definition.
auto FromProto = ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
FirstDeclMatcher<ClassTemplateDecl>().match(FromTU1, Pattern);
Decl *ImportedDef = Import(FromDef, Lang_CXX); Decl *ImportedDef = Import(FromDef, Lang_CXX);
Decl *ImportedProto = Import(FromProto, Lang_CXX); Decl *ImportedProto = Import(FromProto, Lang_CXX);
Decl *ToTU = ImportedDef->getTranslationUnitDecl(); Decl *ToTU = ImportedDef->getTranslationUnitDecl();
EXPECT_NE(ImportedDef, ImportedProto); EXPECT_NE(ImportedDef, ImportedProto);
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 2u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
auto ToDef = FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *ToDef = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
auto ToProto = LastDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *ToProto = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(ImportedDef == ToDef); EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ImportedProto == ToProto); EXPECT_TRUE(ImportedProto == ToProto);
ASSERT_TRUE(ToDef->getTemplatedDecl());
ASSERT_TRUE(ToProto->getTemplatedDecl());
EXPECT_TRUE(ToDef->isThisDeclarationADefinition()); EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition()); EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToProto->getPreviousDecl(), ToDef); EXPECT_EQ(ToProto->getPreviousDecl(), ToDef);
EXPECT_EQ(ToProto->getTemplatedDecl()->getPreviousDecl(), if (auto *ToDefT = dyn_cast<TemplateDecl>(ToDef)) {
ToDef->getTemplatedDecl()); auto *ToProtoT = cast<TemplateDecl>(ToProto);
ASSERT_TRUE(ToDefT->getTemplatedDecl());
ASSERT_TRUE(ToProtoT->getTemplatedDecl());
EXPECT_EQ(ToProtoT->getTemplatedDecl()->getPreviousDecl(),
ToDefT->getTemplatedDecl());
}
} }
TEST_P(ImportClassTemplates, ImportPrototypeThenDefinition) { void TypedTest_ImportPrototypeThenDefinition() {
Decl *FromTU0 = Decl *FromTUProto = getTuDecl(getPrototype(), Lang_CXX, "input0.cc");
getTuDecl("template <class T> class X;", Lang_CXX, "input0.cc"); Decl *FromTUDef = getTuDecl(getDefinition(), Lang_CXX, "input1.cc");
Decl *FromTU1 = auto *FromProto =
getTuDecl("template <class T> class X {};", Lang_CXX, "input1.cc"); FirstDeclMatcher<DeclTy>().match(FromTUProto, getPattern());
auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit())); auto *FromDef = FirstDeclMatcher<DeclTy>().match(FromTUDef, getPattern());
auto FromProto = ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
FirstDeclMatcher<ClassTemplateDecl>().match(FromTU0, Pattern); ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
auto FromDef = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU1, Pattern);
Decl *ImportedProto = Import(FromProto, Lang_CXX); Decl *ImportedProto = Import(FromProto, Lang_CXX);
Decl *ImportedDef = Import(FromDef, Lang_CXX); Decl *ImportedDef = Import(FromDef, Lang_CXX);
Decl *ToTU = ImportedDef->getTranslationUnitDecl(); Decl *ToTU = ImportedDef->getTranslationUnitDecl();
EXPECT_NE(ImportedDef, ImportedProto); EXPECT_NE(ImportedDef, ImportedProto);
EXPECT_EQ(DeclCounter<ClassTemplateDecl>().match(ToTU, Pattern), 2u); EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
auto ToProto = FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *ToProto = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
auto ToDef = LastDeclMatcher<ClassTemplateDecl>().match(ToTU, Pattern); auto *ToDef = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(ImportedDef == ToDef); EXPECT_TRUE(ImportedDef == ToDef);
EXPECT_TRUE(ImportedProto == ToProto); EXPECT_TRUE(ImportedProto == ToProto);
ASSERT_TRUE(ToProto->getTemplatedDecl());
ASSERT_TRUE(ToDef->getTemplatedDecl());
EXPECT_TRUE(ToDef->isThisDeclarationADefinition()); EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
EXPECT_FALSE(ToProto->isThisDeclarationADefinition()); EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
EXPECT_EQ(ToDef->getPreviousDecl(), ToProto); EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
EXPECT_EQ(ToDef->getTemplatedDecl()->getPreviousDecl(), if (auto *ToDefT = dyn_cast<TemplateDecl>(ToDef)) {
ToProto->getTemplatedDecl()); auto *ToProtoT = cast<TemplateDecl>(ToProto);
ASSERT_TRUE(ToDefT->getTemplatedDecl());
ASSERT_TRUE(ToProtoT->getTemplatedDecl());
EXPECT_EQ(ToDefT->getTemplatedDecl()->getPreviousDecl(),
ToProtoT->getTemplatedDecl());
} }
}
void TypedTest_WholeRedeclChainIsImportedAtOnce() {
Decl *FromTU = getTuDecl(getPrototype() + getDefinition(), Lang_CXX);
auto *FromD = // Definition
LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
ASSERT_TRUE(FromD->isThisDeclarationADefinition());
Decl *ImportedD = Import(FromD, Lang_CXX);
Decl *ToTU = ImportedD->getTranslationUnitDecl();
// The whole redecl chain is imported at once.
EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
EXPECT_TRUE(cast<DeclTy>(ImportedD)->isThisDeclarationADefinition());
}
void TypedTest_ImportPrototypeThenProtoAndDefinition() {
{
Decl *FromTU = getTuDecl(getPrototype(), Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
Import(FromD, Lang_CXX);
}
{
Decl *FromTU =
getTuDecl(getPrototype() + getDefinition(), Lang_CXX, "input1.cc");
auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
Import(FromD, Lang_CXX);
}
Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
ASSERT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 3u);
DeclTy *ProtoD = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_FALSE(ProtoD->isThisDeclarationADefinition());
DeclTy *DefinitionD = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
EXPECT_TRUE(DefinitionD->isThisDeclarationADefinition());
EXPECT_TRUE(DefinitionD->getPreviousDecl());
EXPECT_FALSE(
DefinitionD->getPreviousDecl()->isThisDeclarationADefinition());
EXPECT_EQ(DefinitionD->getPreviousDecl()->getPreviousDecl(), ProtoD);
}
};
#define ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(BaseTemplate, TypeParam, \
NamePrefix, TestCase) \
using BaseTemplate##TypeParam = BaseTemplate<TypeParam>; \
TEST_P(BaseTemplate##TypeParam, NamePrefix##TestCase) { \
TypedTest_##TestCase(); \
}
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, Function, ,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, Class, ,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, Variable, ,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, FunctionTemplate, DISABLED_,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, ClassTemplate, ,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, FunctionTemplateSpec, ,
PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, Function, , DefinitionShouldBeImportedAsADefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, Class, , DefinitionShouldBeImportedAsADefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, Variable, , DefinitionShouldBeImportedAsADefinition);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, FunctionTemplate, DISABLED_,
DefinitionShouldBeImportedAsADefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, ClassTemplate, , DefinitionShouldBeImportedAsADefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(
RedeclChain, FunctionTemplateSpec, ,
DefinitionShouldBeImportedAsADefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportPrototypeAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
ImportPrototypeAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportPrototypeAfterImportedPrototype);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
ImportPrototypeAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
ImportPrototypeAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec, ,
ImportPrototypeAfterImportedPrototype);
a_sidorinUnsubmitted
Done
ReplyInline Actions

Is it possible to disable the tests instead of commenting them out?

a_sidorin: Is it possible to disable the tests instead of commenting them out?
martongAuthorUnsubmitted
Done
ReplyInline Actions

Okay, I have changed the macro so we can disable the tests.

martong: Okay, I have changed the macro so we can disable the tests.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportDefinitionAfterImportedPrototype);
// FIXME This does not pass, possible error with Class import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, DISABLED_,
ImportDefinitionAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportDefinitionAfterImportedPrototype);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
ImportDefinitionAfterImportedPrototype);
// FIXME This does not pass, possible error with ClassTemplate import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, DISABLED_,
ImportDefinitionAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec, ,
ImportDefinitionAfterImportedPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportPrototypeAfterImportedDefinition);
// FIXME This does not pass, possible error with Class import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, DISABLED_,
ImportPrototypeAfterImportedDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportPrototypeAfterImportedDefinition);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
ImportPrototypeAfterImportedDefinition);
// FIXME This does not pass, possible error with ClassTemplate import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, DISABLED_,
ImportPrototypeAfterImportedDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec, ,
ImportPrototypeAfterImportedDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportPrototypes);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, , ImportPrototypes);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportPrototypes);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_, ImportPrototypes);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
ImportPrototypes);
// FIXME This does not pass, possible error with Spec import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec,
DISABLED_, ImportPrototypes);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportDefinitions);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
ImportDefinitions);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportDefinitions);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_, ImportDefinitions);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
ImportDefinitions);
// FIXME This does not pass, possible error with Spec import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec,
DISABLED_, ImportDefinitions);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportDefinitionThenPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
ImportDefinitionThenPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportDefinitionThenPrototype);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
ImportDefinitionThenPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
ImportDefinitionThenPrototype);
// FIXME This does not pass, possible error with Spec import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec,
DISABLED_,
ImportDefinitionThenPrototype);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportPrototypeThenDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Class, ,
ImportPrototypeThenDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportPrototypeThenDefinition);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
ImportPrototypeThenDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, ClassTemplate, ,
ImportPrototypeThenDefinition);
// FIXME This does not pass, possible error with Spec import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec,
DISABLED_,
ImportPrototypeThenDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
WholeRedeclChainIsImportedAtOnce);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
WholeRedeclChainIsImportedAtOnce);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
WholeRedeclChainIsImportedAtOnce);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec, ,
WholeRedeclChainIsImportedAtOnce);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Function, ,
ImportPrototypeThenProtoAndDefinition);
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, Variable, ,
ImportPrototypeThenProtoAndDefinition);
// FIXME Enable this test, once we import function templates chains correctly.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplate,
DISABLED_,
ImportPrototypeThenProtoAndDefinition);
// FIXME This does not pass, possible error with Spec import.
ASTIMPORTER_INSTANTIATE_TYPED_TEST_CASE(RedeclChain, FunctionTemplateSpec,
DISABLED_,
ImportPrototypeThenProtoAndDefinition);
INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainFunction,
DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainClass,
DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainVariable,
DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainFunctionTemplate,
DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainClassTemplate,
DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, RedeclChainFunctionTemplateSpec,
DefaultTestValuesForRunOptions, );
struct ImportFriendClasses : ASTImporterTestBase {}; struct ImportFriendClasses : ASTImporterTestBase {};
TEST_P(ImportFriendClasses, ImportOfFriendRecordDoesNotMergeDefinition) { TEST_P(ImportFriendClasses, ImportOfFriendRecordDoesNotMergeDefinition) {
Decl *FromTU = getTuDecl( Decl *FromTU = getTuDecl(
R"( R"(
class A { class A {
template <int I> class F {}; template <int I> class F {};
▲ Show 20 Lines • Show All 443 Lines • ▼ Show 20 LinesTEST_P(ImportFunctionTemplateSpecializations,
Import(FromD, Lang_CXX11); Import(FromD, Lang_CXX11);
auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl(); auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
EXPECT_EQ( EXPECT_EQ(
DeclCounter<FunctionDecl>().match(FromTU, functionDecl(hasName("f"))), DeclCounter<FunctionDecl>().match(FromTU, functionDecl(hasName("f"))),
DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f")))); DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f"))));
} }
TEST_P(ImportFunctionTemplateSpecializations,
ImportPrototypes) {
auto Pattern = functionDecl(hasName("f"), isExplicitTemplateSpecialization());
auto Code =
R"(
// Proto of the primary template.
template <class T>
void f();
// Proto of the specialization.
template <>
void f<int>();
)";
Decl *ImportedD;
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input0.cc");
auto *FromD = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input1.cc");
auto *FromD = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(ImportedD != To1);
EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
EXPECT_FALSE(To1->doesThisDeclarationHaveABody());
// Check that they are part of the same redecl chain.
EXPECT_EQ(To1->getCanonicalDecl(), To0->getCanonicalDecl());
}
TEST_P(ImportFunctionTemplateSpecializations, ImportDefinitions) {
auto Pattern = functionDecl(hasName("f"), isExplicitTemplateSpecialization());
auto Code =
R"(
// Proto of the primary template.
template <class T>
void f();
// Specialization and definition.
template <>
void f<int>() {}
)";
Decl *ImportedD;
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input1.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 1u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(To0->doesThisDeclarationHaveABody());
auto *TemplateD = FirstDeclMatcher<FunctionTemplateDecl>().match(
ToTU, functionTemplateDecl());
auto *FirstSpecD = *(TemplateD->spec_begin());
EXPECT_EQ(FirstSpecD->getCanonicalDecl(), To0->getCanonicalDecl());
}
TEST_P(ImportFunctionTemplateSpecializations, PrototypeThenPrototype) {
auto Pattern = functionDecl(hasName("f"), isExplicitTemplateSpecialization());
auto Code =
R"(
// Proto of the primary template.
template <class T>
void f();
// Specialization proto.
template <>
void f<int>();
// Specialization proto.
template <>
void f<int>();
)";
Decl *ImportedD;
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(ImportedD != To1);
EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
EXPECT_FALSE(To1->doesThisDeclarationHaveABody());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ImportFunctionTemplateSpecializations, PrototypeThenDefinition) {
auto Pattern = functionDecl(hasName("f"), isExplicitTemplateSpecialization());
auto Code =
R"(
// Proto of the primary template.
template <class T>
void f();
// Specialization proto.
template <>
void f<int>();
// Specialization definition.
template <>
void f<int>() {}
)";
Decl *ImportedD;
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(ImportedD != To1);
EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
EXPECT_TRUE(To1->doesThisDeclarationHaveABody());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ImportFunctionTemplateSpecializations, DefinitionThenPrototype) {
auto Pattern = functionDecl(hasName("f"), isExplicitTemplateSpecialization());
auto Code =
R"(
// Proto of the primary template.
template <class T>
void f();
// Specialization definition.
template <>
void f<int>() {}
// Specialization proto.
template <>
void f<int>();
)";
Decl *ImportedD;
{
Decl *FromTU = getTuDecl(Code, Lang_CXX, "input0.cc");
auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
ImportedD = Import(FromD, Lang_CXX);
}
Decl *ToTU = ImportedD->getTranslationUnitDecl();
EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
EXPECT_TRUE(ImportedD == To0);
EXPECT_TRUE(ImportedD != To1);
EXPECT_TRUE(To0->doesThisDeclarationHaveABody());
EXPECT_FALSE(To1->doesThisDeclarationHaveABody());
EXPECT_EQ(To1->getPreviousDecl(), To0);
}
TEST_P(ASTImporterTestBase, TEST_P(ASTImporterTestBase,
ImportShouldNotReportFalseODRErrorWhenRecordIsBeingDefined) { ImportShouldNotReportFalseODRErrorWhenRecordIsBeingDefined) {
{ {
Decl *FromTU = getTuDecl( Decl *FromTU = getTuDecl(
R"( R"(
template <typename T> template <typename T>
struct B; struct B;
)", )",
▲ Show 20 Lines • Show All 472 Lines • ▼ Show 20 Lines
INSTANTIATE_TEST_CASE_P(ParameterizedTests, DeclContextTest, INSTANTIATE_TEST_CASE_P(ParameterizedTests, DeclContextTest,
::testing::Values(ArgVector()), ); ::testing::Values(ArgVector()), );
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
ParameterizedTests, CanonicalRedeclChain, ParameterizedTests, CanonicalRedeclChain,
::testing::Values(ArgVector()),); ::testing::Values(ArgVector()),);
auto DefaultTestValuesForRunOptions = ::testing::Values(
ArgVector(),
ArgVector{"-fdelayed-template-parsing"},
ArgVector{"-fms-compatibility"},
ArgVector{"-fdelayed-template-parsing", "-fms-compatibility"});
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterLookupTableTest, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterLookupTableTest,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportExpr, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportExpr,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportType, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportType,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportDecl, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportDecl,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterTestBase, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterTestBase,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctions, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctions,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClasses, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClasses,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendFunctions, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendFunctions,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClassTemplates,
DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendClasses, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFriendClasses,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, INSTANTIATE_TEST_CASE_P(ParameterizedTests,
ImportFunctionTemplateSpecializations, ImportFunctionTemplateSpecializations,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportImplicitMethods, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportImplicitMethods,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportVariables, INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportVariables,
DefaultTestValuesForRunOptions, ); DefaultTestValuesForRunOptions, );
} // end namespace ast_matchers } // end namespace ast_matchers
} // end namespace clang } // end namespace clang