if (Error Err = ImportTemplateInformation(D, ToFunction))
return std::move(Err);
+ if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
+ if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction),
+ FromCXXMethod))
+ return std::move(Err);
+
if (D->doesThisDeclarationHaveABody()) {
Error Err = ImportFunctionDeclBody(D, ToFunction);
addDeclToContexts(D, ToFunction);
- if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
- if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction),
- FromCXXMethod))
- return std::move(Err);
-
// Import the rest of the chain. I.e. import all subsequent declarations.
for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
EXPECT_EQ(ToDFOutOfClass->getPreviousDecl(), ToDFInClass);
}
+TEST_P(ASTImporterOptionSpecificTestBase,
+ ImportVirtualOverriddenMethodOnALoopTest) {
+ // B::f() calls => f1() ==> C ==> C::f()
+ // \
+ // \---- A::f()
+ //
+ // C::f()'s ImportOverriddenMethods() asserts B::isVirtual(), so B::f()'s
+ // ImportOverriddenMethods() should be completed before B::f()'s body
+ const char *Code =
+ R"(
+ void f1();
+ class A {
+ virtual void f(){}
+ };
+ class B: public A {
+ void f() override {
+ f1();
+ }
+ };
+ class C: public B {
+ void f() override {}
+ };
+ void f1() { C c; }
+ )";
+ Decl *FromTU = getTuDecl(Code, Lang_CXX11);
+
+ auto *FromF = FirstDeclMatcher<CXXMethodDecl>().match(
+ FromTU, cxxMethodDecl(hasName("B::f")));
+
+ auto *ToBF = Import(FromF, Lang_CXX11);
+ EXPECT_TRUE(ToBF->isVirtual());
+
+ auto *ToCF = FirstDeclMatcher<CXXMethodDecl>().match(
+ ToBF->getTranslationUnitDecl(), cxxMethodDecl(hasName("C::f")));
+ EXPECT_TRUE(ToCF->isVirtual());
+}
+
TEST_P(ASTImporterOptionSpecificTestBase, ImportVariableChainInC) {
std::string Code = "static int v; static int v = 0;";
auto Pattern = varDecl(hasName("v"));