llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang <details> <summary>Changes</summary> A problem with AST import could lead to multiple instances of the same template class specialization, with different template arguments. The difference was caused by pointers to different declarations of the same function. Problem is fixed by using the canonical declaration at import. --- Full diff: https://github.com/llvm/llvm-project/pull/67680.diff 2 Files Affected: - (modified) clang/lib/AST/ASTImporter.cpp (+2-1) - (modified) clang/unittests/AST/ASTImporterTest.cpp (+58) ``````````diff diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index c7c2aecc8b179a4..bea6ab40a3437e3 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -811,7 +811,8 @@ ASTNodeImporter::import(const TemplateArgument &From) { ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl()); if (!ToTypeOrErr) return ToTypeOrErr.takeError(); - return TemplateArgument(*ToOrErr, *ToTypeOrErr, From.getIsDefaulted()); + return TemplateArgument(dyn_cast<ValueDecl>((*ToOrErr)->getCanonicalDecl()), + *ToTypeOrErr, From.getIsDefaulted()); } case TemplateArgument::NullPtr: { diff --git a/clang/unittests/AST/ASTImporterTest.cpp b/clang/unittests/AST/ASTImporterTest.cpp index 65a5b630e462d0f..abdb80373a5f90e 100644 --- a/clang/unittests/AST/ASTImporterTest.cpp +++ b/clang/unittests/AST/ASTImporterTest.cpp @@ -9147,6 +9147,64 @@ TEST_P(ASTImporterOptionSpecificTestBase, EXPECT_TRUE(ToXType->typeMatchesDecl()); } +TEST_P(ASTImporterOptionSpecificTestBase, + ImportTemplateArgumentWithPointerToDifferentInstantiation) { + const char *CodeTo = + R"( + template<class A> + A f1() { + return A(); + } + template<class A, A (B)()> + class X {}; + + X<int, f1<int>> x; + )"; + const char *CodeFrom = + R"( + template<class A> + A f1(); + template<class A, A (B)()> + class X {}; + + X<int, f1<int>> x; + )"; + Decl *ToTU = getToTuDecl(CodeTo, Lang_CXX11); + Decl *FromTU = getTuDecl(CodeFrom, Lang_CXX11); + + auto *ToF1 = FirstDeclMatcher<FunctionDecl>().match( + ToTU, functionDecl(hasName("f1"), isInstantiated())); + auto *FromF1 = FirstDeclMatcher<FunctionDecl>().match( + FromTU, functionDecl(hasName("f1"), isInstantiated())); + EXPECT_TRUE(ToF1->isThisDeclarationADefinition()); + EXPECT_FALSE(FromF1->isThisDeclarationADefinition()); + + auto *ToX = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match( + ToTU, classTemplateSpecializationDecl(hasName("X"))); + auto *FromX = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match( + FromTU, classTemplateSpecializationDecl(hasName("X"))); + + Decl *ToTArgF = ToX->getTemplateArgs().get(1).getAsDecl(); + Decl *FromTArgF = FromX->getTemplateArgs().get(1).getAsDecl(); + EXPECT_EQ(ToTArgF, ToF1); + EXPECT_EQ(FromTArgF, FromF1); + + auto *ToXImported = Import(FromX, Lang_CXX11); + // The template argument 1 of 'X' in the "From" code points to a function + // that has no definition. The import must ensure that this template argument + // is imported in a way that it will point to the existing 'f1' function, not + // to the 'f1' that is imported. In this way when specialization of 'X' is + // imported it will have the same template arguments as the existing one. + EXPECT_EQ(ToXImported, ToX); + // FIXME: This matcher causes a crash "Tried to match orphan node". + // The code is removed until the problem is fixed. + // auto *ToF1Imported = + // LastDeclMatcher<FunctionDecl>().match(ToTU, + // functionDecl(hasName("f1"),isInstantiated())); + // EXPECT_NE(ToF1Imported, ToF1); + // EXPECT_EQ(ToF1Imported->getPreviousDecl(), ToF1); +} + INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ASTImporterLookupTableTest, DefaultTestValuesForRunOptions); `````````` </details> https://github.com/llvm/llvm-project/pull/67680 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
