maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Modules/submodules-merge-defs.cpp

128 lines
5.3 KiB
C++
Raw Normal View History

[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
// RUN: rm -rf %t
[modules] Simplify -cc1 interface for enabling implicit module maps. We used to have a flag to enable module maps, and two more flags to enable implicit module maps. This is all redundant; we don't need any flag for enabling module maps in the abstract, and we don't usually have -fno- flags for -cc1. We now have just a single flag, -fimplicit-module-maps, that enables implicitly searching the file system for module map files and loading them. The driver interface is unchanged for now. We should probably rename -fmodule-maps to -fimplicit-module-maps at some point. llvm-svn: 239789
2015-06-16 08:08:24 +08:00
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -DTEXTUAL
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility
Revert r240335. This failed to solve the problem it was aimed at, and introduced just as many issues as it resolved. Realistically, we need to deal with the possibility that multiple modules might define different internal linkage symbols with the same name, and this isn't a problem unless two such symbols are simultaneously visible. The case where two modules define equivalent internal linkage symbols is handled by r252063: if lookup finds multiple sufficiently-similar entities from different modules, we just pick one of them as an extension (but we keep them separate). llvm-svn: 252957
2015-11-13 05:55:58 +08:00
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -DTEXTUAL -DEARLY_INDIRECT_INCLUDE
[modules] Simplify -cc1 interface for enabling implicit module maps. We used to have a flag to enable module maps, and two more flags to enable implicit module maps. This is all redundant; we don't need any flag for enabling module maps in the abstract, and we don't usually have -fno- flags for -cc1. We now have just a single flag, -fimplicit-module-maps, that enables implicitly searching the file system for module map files and loading them. The driver interface is unchanged for now. We should probably rename -fmodule-maps to -fimplicit-module-maps at some point. llvm-svn: 239789
2015-06-16 08:08:24 +08:00
// RUN: %clang_cc1 -x c++ -std=c++11 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/submodules-merge-defs %s -verify -fno-modules-error-recovery -fmodules-local-submodule-visibility -fmodule-feature use_defs_twice -DIMPORT_USE_2
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
// Trigger import of definitions, but don't make them visible.
#include "empty.h"
[modules] Fix a few places where merging wasn't performed if modules was disabled but local module visibilty was enabled. llvm-svn: 239504
2015-06-11 11:05:39 +08:00
#ifdef EARLY_INDIRECT_INCLUDE
#include "indirect.h"
#endif
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
A pre_a;
[modules] Better support for redefinitions of an entity from the same module. Support this across module save/reload and extend the 'missing import' diagnostics with a list of providing modules. llvm-svn: 239750
2015-06-16 04:15:48 +08:00
#ifdef IMPORT_USE_2
// expected-error-re@-2 {{must be imported from one of {{.*}}stuff.use{{.*}}stuff.use-2}}
#elif EARLY_INDIRECT_INCLUDE
// expected-error@-4 {{must be imported from module 'merged-defs'}}
#else
// expected-error@-6 {{must be imported from module 'stuff.use'}}
#endif
[modules] Allow a function to be redefined if the old definition is not visible. llvm-svn: 233407
2015-03-28 04:16:58 +08:00
// expected-note@defs.h:1 +{{here}}
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
extern class A pre_a2;
[modules] Don't try to use the definition of a class if RequireCompleteType(..., 0) says we're not permitted to do so. The definition might not be visible, even though we know what it is. llvm-svn: 256045
2015-12-19 06:19:11 +08:00
int pre_use_a = use_a(pre_a2); // expected-error 2{{'A' must be imported}} expected-error {{'use_a' must be imported}}
[modules] Apply name visibility rules to names found by ADL. llvm-svn: 239578
2015-06-12 09:32:13 +08:00
// expected-note@defs.h:2 +{{here}}
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
[modules] Handle defining a class template on top of an existing imported-but-not-visible definition. llvm-svn: 233341
2015-03-27 08:41:57 +08:00
B::Inner2 pre_bi; // expected-error +{{must be imported}}
// expected-note@defs.h:4 +{{here}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:17 +{{here}}
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
void pre_bfi(B b) { // expected-error +{{must be imported}}
b.f<int>(); // expected-error +{{}}
[modules] Don't make out-of-line member specializations of an instantiated class template specialization visible just because the class template specialization's definition is visible. llvm-svn: 241182
2015-07-02 03:32:54 +08:00
}
[modules] Handle defining a class template on top of an existing imported-but-not-visible definition. llvm-svn: 233341
2015-03-27 08:41:57 +08:00
C_Base<1> pre_cb1; // expected-error +{{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:23 +{{here}}
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
C1 pre_c1; // expected-error +{{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:25 +{{here}}
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
C2 pre_c2; // expected-error +{{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:26 +{{here}}
[modules] Handle defining a class template on top of an existing imported-but-not-visible definition. llvm-svn: 233341
2015-03-27 08:41:57 +08:00
[modules] Handle defining a tag with a typedef name for linkage purposes on top of an existing imported-but-not-visible definition. llvm-svn: 233345
2015-03-27 09:37:43 +08:00
D::X pre_dx; // expected-error +{{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:28 +{{here}}
// expected-note@defs.h:29 +{{here}}
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
int pre_use_dx = use_dx(pre_dx); // ignored; pre_dx is invalid
[modules] Handle defining a tag with a typedef name for linkage purposes on top of an existing imported-but-not-visible definition. llvm-svn: 233345
2015-03-27 09:37:43 +08:00
[modules] Allow a function template definition if we have a pre-existing but not visible definition of the same template. llvm-svn: 233430
2015-03-28 05:57:41 +08:00
int pre_e = E(0); // expected-error {{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:32 +{{here}}
[modules] Allow a function template definition if we have a pre-existing but not visible definition of the same template. llvm-svn: 233430
2015-03-28 05:57:41 +08:00
int pre_ff = F<int>().f(); // expected-error +{{must be imported}}
[modules] Don't try to use the definition of a class if RequireCompleteType(..., 0) says we're not permitted to do so. The definition might not be visible, even though we know what it is. llvm-svn: 256045
2015-12-19 06:19:11 +08:00
int pre_fg = F<int>().g<int>(); // expected-error +{{must be imported}} expected-error 2{{expected}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:34 +{{here}}
[modules] Allow a function template definition if we have a pre-existing but not visible definition of the same template. llvm-svn: 233430
2015-03-28 05:57:41 +08:00
[modules] Ensure that if we merge the definitions of two enumerations, that making either of them visible makes the merged definition visible. llvm-svn: 239969
2015-06-18 07:07:50 +08:00
G::A pre_ga // expected-error +{{must be imported}}
= G::a; // expected-error +{{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:49 +{{here}}
// expected-note@defs.h:50 +{{here}}
[modules] Don't make out-of-line member specializations of an instantiated class template specialization visible just because the class template specialization's definition is visible. llvm-svn: 241182
2015-07-02 03:32:54 +08:00
decltype(G::h) pre_gh = G::h; // expected-error +{{must be imported}}
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:51 +{{here}}
[modules] Ensure that if we merge the definitions of two enumerations, that making either of them visible makes the merged definition visible. llvm-svn: 239969
2015-06-18 07:07:50 +08:00
[modules] Improve diagnostic for a template-id that's invalid because a default argument is not visible. llvm-svn: 239934
2015-06-18 04:16:32 +08:00
J<> pre_j; // expected-error {{declaration of 'J' must be imported}}
#ifdef IMPORT_USE_2
[modules] If we merge a template, also track that its parameters are merged so that we know when its default arguments should be visible. llvm-svn: 239936
2015-06-18 04:39:41 +08:00
// expected-error-re@-2 {{default argument of 'J' must be imported from one of {{.*}}stuff.use{{.*}}stuff.use-2}}
[modules] Improve diagnostic for a template-id that's invalid because a default argument is not visible. llvm-svn: 239934
2015-06-18 04:16:32 +08:00
#elif EARLY_INDIRECT_INCLUDE
[modules] If we merge a template, also track that its parameters are merged so that we know when its default arguments should be visible. llvm-svn: 239936
2015-06-18 04:39:41 +08:00
// expected-error@-4 {{default argument of 'J' must be imported from module 'merged-defs'}}
[modules] Improve diagnostic for a template-id that's invalid because a default argument is not visible. llvm-svn: 239934
2015-06-18 04:16:32 +08:00
#else
[modules] If we merge a template, also track that its parameters are merged so that we know when its default arguments should be visible. llvm-svn: 239936
2015-06-18 04:39:41 +08:00
// expected-error@-6 {{default argument of 'J' must be imported from module 'stuff.use'}}
[modules] Improve diagnostic for a template-id that's invalid because a default argument is not visible. llvm-svn: 239934
2015-06-18 04:16:32 +08:00
#endif
[modules] When parsing the base specifiers of a parse-merged class, the current context is the class itself but lookups should be performed starting with the lookup parent of the class (class and base members don't shadow types from the surrounding context because they have not been declared yet). llvm-svn: 245236
2015-08-18 04:24:17 +08:00
// expected-note@defs.h:58 +{{here}}
[modules] Fix crash with multiple levels of default template argument merging. llvm-svn: 239575
2015-06-12 07:46:11 +08:00
[modules] Simplify and generalize the existing rule for finding hidden declarations in redeclaration lookup. A declaration is now visible to lookup if: * It is visible (not in a module, or in an imported module), or * We're doing redeclaration lookup and it's externally-visible, or * We're doing typo correction and looking for unimported decls. We now support multiple modules having different internal-linkage or no-linkage definitions of the same name for all entities, not just for functions, variables, and some typedefs. As previously, if multiple such entities are visible, any attempt to use them will result in an ambiguity error. This patch fixes the linkage calculation for a number of entities where we previously didn't need to get it right (using-declarations, namespace aliases, and so on). It also classifies enumerators as always having no linkage, which is a slight deviation from the C++ standard's definition, but not an observable change outside modules (this change is being discussed on the -core reflector currently). This also removes the prior special case for tag lookup, which made some cases of this work, but also led to bizarre, bogus "must use 'struct' to refer to type 'Foo' in this scope" diagnostics in C++. llvm-svn: 252960
2015-11-13 06:19:45 +08:00
ScopedEnum pre_scopedenum; // expected-error {{must be imported}}
// expected-note@defs.h:105 0-1{{here}}
// expected-note@defs.h:106 0-1{{here}}
[modules] Fix merging support for forward-declared enums with fixed underlying types. A visible declaration is enough to make the type complete, but not enough to make the definition visible. llvm-svn: 241743
2015-07-09 05:49:31 +08:00
enum ScopedEnum : int;
ScopedEnum pre_scopedenum_declared; // ok
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
// Make definitions from second module visible.
[modules] When merging class definitions, make the retained definition visible if the merged definition is visible, and perform lookups into all merged copies of the definition (not just for special members) so that we can complete the redecl chains for members of the class. llvm-svn: 233420
2015-03-28 05:16:39 +08:00
#ifdef TEXTUAL
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
#include "import-and-redefine.h"
[modules] Better support for redefinitions of an entity from the same module. Support this across module save/reload and extend the 'missing import' diagnostics with a list of providing modules. llvm-svn: 239750
2015-06-16 04:15:48 +08:00
#elif defined IMPORT_USE_2
#include "use-defs-2.h"
[modules] When merging class definitions, make the retained definition visible if the merged definition is visible, and perform lookups into all merged copies of the definition (not just for special members) so that we can complete the redecl chains for members of the class. llvm-svn: 233420
2015-03-28 05:16:39 +08:00
#else
#include "merged-defs.h"
#endif
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
A post_a;
[modules] Allow a function to be redefined if the old definition is not visible. llvm-svn: 233407
2015-03-28 04:16:58 +08:00
int post_use_a = use_a(post_a);
[modules] Handle defining a class template on top of an existing imported-but-not-visible definition. llvm-svn: 233341
2015-03-27 08:41:57 +08:00
B::Inner2 post_bi;
[modules] Don't make out-of-line member specializations of an instantiated class template specialization visible just because the class template specialization's definition is visible. llvm-svn: 241182
2015-07-02 03:32:54 +08:00
void post_bfi(B b) {
b.f<int>();
}
[modules] Handle defining a class template on top of an existing imported-but-not-visible definition. llvm-svn: 233341
2015-03-27 08:41:57 +08:00
C_Base<1> post_cb1;
C1 c1;
C2 c2;
[modules] Handle defining a tag with a typedef name for linkage purposes on top of an existing imported-but-not-visible definition. llvm-svn: 233345
2015-03-27 09:37:43 +08:00
D::X post_dx;
[modules] Allow a function to be redefined if the old definition is not visible. llvm-svn: 233407
2015-03-28 04:16:58 +08:00
int post_use_dx = use_dx(post_dx);
[modules] Allow a function template definition if we have a pre-existing but not visible definition of the same template. llvm-svn: 233430
2015-03-28 05:57:41 +08:00
int post_e = E(0);
int post_ff = F<char>().f();
int post_fg = F<char>().g<int>();
[modules] Ensure that if we merge the definitions of two enumerations, that making either of them visible makes the merged definition visible. llvm-svn: 239969
2015-06-18 07:07:50 +08:00
G::A post_ga = G::a;
decltype(G::h) post_gh = G::h;
[modules] Fix crash with multiple levels of default template argument merging. llvm-svn: 239575
2015-06-12 07:46:11 +08:00
J<> post_j;
template<typename T, int N, template<typename> class K> struct J;
J<> post_j2;
[modules] Fix merging of default template arguments onto friend templates. Previously we'd complain about redefinition of default arguments when we instantiated a class with a friend template that inherits its default argument, because we propagate the default template arguemnt onto the friend when we reload the AST. llvm-svn: 239857
2015-06-17 05:57:05 +08:00
FriendDefArg::Y<int> friend_def_arg;
[modules] Fix typo in default argument merging. llvm-svn: 239954
2015-06-18 06:13:23 +08:00
FriendDefArg::D<> friend_def_arg_d;
[modules] Make IndirectFieldDecl mergeable to avoid lookup ambiguity when the same anonymous union is defined across multiple modules. llvm-svn: 243940
2015-08-04 10:05:09 +08:00
int post_anon_x_n = Anon::X().n;
[modules] Add a flag to disable the feature that permits conflicting redefinitions of internal-linkage symbols that are not visible. Such conflicts are an accident waiting to happen, and this feature conflicts with the desire to include existing headers into multiple modules and merge the results. (In an ideal world, it should not be possible to export internal linkage symbols from a module, but sadly the glibc and libstdc++ headers provide 'static inline' functions in a few cases.) llvm-svn: 240335
2015-06-23 05:15:01 +08:00
[modules] Merging support for specializations of a function template. This very rarely matters, but can affect whether two dependent types are canonically equivalent. llvm-svn: 241207
2015-07-02 07:19:58 +08:00
MergeFunctionTemplateSpecializations::X<int>::Q<char> xiqc;
[modules] Add a flag to disable the feature that permits conflicting redefinitions of internal-linkage symbols that are not visible. Such conflicts are an accident waiting to happen, and this feature conflicts with the desire to include existing headers into multiple modules and merge the results. (In an ideal world, it should not be possible to export internal linkage symbols from a module, but sadly the glibc and libstdc++ headers provide 'static inline' functions in a few cases.) llvm-svn: 240335
2015-06-23 05:15:01 +08:00
#ifdef TEXTUAL
#include "use-defs.h"
void use_static_inline() { StaticInline::g({}); }
Revert r240335. This failed to solve the problem it was aimed at, and introduced just as many issues as it resolved. Realistically, we need to deal with the possibility that multiple modules might define different internal linkage symbols with the same name, and this isn't a problem unless two such symbols are simultaneously visible. The case where two modules define equivalent internal linkage symbols is handled by r252063: if lookup finds multiple sufficiently-similar entities from different modules, we just pick one of them as an extension (but we keep them separate). llvm-svn: 252957
2015-11-13 05:55:58 +08:00
#ifdef EARLY_INDIRECT_INCLUDE
// expected-warning@-2 {{ambiguous use of internal linkage declaration 'g' defined in multiple modules}}
// expected-note@defs.h:71 {{declared here in module 'redef'}}
// expected-note@defs.h:71 {{declared here in module 'stuff.use'}}
#endif
[modules] Follow the C++ standard's rule for linkage of enumerators: they have the linkage of the enumeration. For enumerators of unnamed enumerations, extend the -Wmodules-ambiguous-internal-linkage extension to allow selecting an arbitrary enumerator (but only if they all have the same value, otherwise it's ambiguous). llvm-svn: 253010
2015-11-13 11:52:13 +08:00
int use_anon_enum = G::g;
#ifdef EARLY_INDIRECT_INCLUDE
// expected-warning@-2 3{{ambiguous use of internal linkage declaration 'g' defined in multiple modules}}
// FIXME: These notes are produced, but -verify can't match them?
// FIXME-note@defs.h:51 3{{declared here in module 'redef'}}
// FIXME-note@defs.h:51 3{{declared here in module 'stuff.use'}}
#endif
int use_named_enum = G::i;
[modules] Add a flag to disable the feature that permits conflicting redefinitions of internal-linkage symbols that are not visible. Such conflicts are an accident waiting to happen, and this feature conflicts with the desire to include existing headers into multiple modules and merge the results. (In an ideal world, it should not be possible to export internal linkage symbols from a module, but sadly the glibc and libstdc++ headers provide 'static inline' functions in a few cases.) llvm-svn: 240335
2015-06-23 05:15:01 +08:00
#endif