From d6aab59ad1e569b50660159e8128797d179bd768 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Fri, 27 Mar 2015 21:57:41 +0000 Subject: [PATCH] [modules] Allow a function template definition if we have a pre-existing but not visible definition of the same template. llvm-svn: 233430 --- clang/lib/Sema/SemaDecl.cpp | 9 +++++--- .../Inputs/submodules-merge-defs/defs.h | 11 ++++++++++ clang/test/Modules/submodules-merge-defs.cpp | 22 ++++++++++++++----- 3 files changed, 33 insertions(+), 9 deletions(-) diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 3b9bb842c4e5..ce183d0adf43 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -10282,13 +10282,16 @@ Sema::CheckForFunctionRedefinition(FunctionDecl *FD, if (canRedefineFunction(Definition, getLangOpts())) return; - // If we don't have a visible definition of the function, and it's inline, - // it's OK to form another definition of it. + // If we don't have a visible definition of the function, and it's inline or + // a template, it's OK to form another definition of it. // // FIXME: Should we skip the body of the function and use the old definition // in this case? That may be necessary for functions that return local types // through a deduced return type, or instantiate templates with local types. - if (!hasVisibleDefinition(Definition) && Definition->isInlineSpecified()) + if (!hasVisibleDefinition(Definition) && + (Definition->isInlineSpecified() || + Definition->getDescribedFunctionTemplate() || + Definition->getNumTemplateParameterLists())) return; if (getLangOpts().GNUMode && Definition->isInlineSpecified() && diff --git a/clang/test/Modules/Inputs/submodules-merge-defs/defs.h b/clang/test/Modules/Inputs/submodules-merge-defs/defs.h index 3a9c2327c7a7..89e4b2319c9d 100644 --- a/clang/test/Modules/Inputs/submodules-merge-defs/defs.h +++ b/clang/test/Modules/Inputs/submodules-merge-defs/defs.h @@ -5,9 +5,11 @@ class B { struct Inner1 {}; public: struct Inner2; + template void f(); }; // Check that lookup and access checks are performed in the right context. struct B::Inner2 : Inner1 {}; +template void B::f() {} // Check that base-specifiers are correctly disambiguated. template struct C_Base { struct D { constexpr operator int() const { return 0; } }; }; @@ -18,3 +20,12 @@ struct C2 : C_Base::D{} extern c2; typedef struct { int a; void f(); struct X; } D; struct D::X { int dx; } extern dx; inline int use_dx(D::X dx) { return dx.dx; } + +template int E(T t) { return t; } + +template struct F { + int f(); + template int g(); +}; +template int F::f() { return 0; } +template template int F::g() { return 0; } diff --git a/clang/test/Modules/submodules-merge-defs.cpp b/clang/test/Modules/submodules-merge-defs.cpp index 3bc52fee828f..79213cae8fa2 100644 --- a/clang/test/Modules/submodules-merge-defs.cpp +++ b/clang/test/Modules/submodules-merge-defs.cpp @@ -12,21 +12,28 @@ int pre_use_a = use_a(pre_a); // expected-error {{'A' must be imported}} B::Inner2 pre_bi; // expected-error +{{must be imported}} // expected-note@defs.h:4 +{{here}} -// expected-note@defs.h:10 +{{here}} +// expected-note@defs.h:11 +{{here}} C_Base<1> pre_cb1; // expected-error +{{must be imported}} -// expected-note@defs.h:13 +{{here}} -C1 pre_c1; // expected-error +{{must be imported}} expected-error {{must use 'struct'}} // expected-note@defs.h:15 +{{here}} +C1 pre_c1; // expected-error +{{must be imported}} expected-error {{must use 'struct'}} +// expected-note@defs.h:17 +{{here}} C2 pre_c2; // expected-error +{{must be imported}} expected-error {{must use 'struct'}} -// expected-note@defs.h:16 +{{here}} +// expected-note@defs.h:18 +{{here}} D::X pre_dx; // expected-error +{{must be imported}} -// expected-note@defs.h:18 +{{here}} -// expected-note@defs.h:19 +{{here}} +// expected-note@defs.h:20 +{{here}} +// expected-note@defs.h:21 +{{here}} // FIXME: We should warn that use_dx is being used without being imported. int pre_use_dx = use_dx(pre_dx); +int pre_e = E(0); // expected-error {{must be imported}} +// expected-note@defs.h:24 +{{here}} + +int pre_ff = F().f(); // expected-error +{{must be imported}} +int pre_fg = F().g(); // expected-error +{{must be imported}} +// expected-note@defs.h:26 +{{here}} + // Make definitions from second module visible. #ifdef TEXTUAL #include "import-and-redefine.h" @@ -42,3 +49,6 @@ C1 c1; C2 c2; D::X post_dx; int post_use_dx = use_dx(post_dx); +int post_e = E(0); +int post_ff = F().f(); +int post_fg = F().g(); -- 2.34.1