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

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

125 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"
Implement P1766R1: diagnose giving non-C-compatible classes a typedef name for linkage purposes. Summary: Due to a recent (but retroactive) C++ rule change, only sufficiently C-compatible classes are permitted to be given a typedef name for linkage purposes. Add an enabled-by-default warning for these cases, and rephrase our existing error for the case where we encounter the typedef name for linkage after we've already computed and used a wrong linkage in terms of the new rule. Reviewers: rjmccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D74103
2020-02-06 10:52:38 +08:00
// expected-warning@defs.h:28 3{{anonymous non-C-compatible type}}
// expected-note@defs.h:28 6{{type is}}
[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
#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;
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
// expected-error-re@-1 {{missing '#include "{{.*}}-defs.h"'; 'A' must be declared}}
[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;
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
int pre_use_a = use_a(pre_a2); // expected-error 2{{'A' must be defined}} expected-error {{'use_a' must be declared}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
B::Inner2 pre_bi; // expected-error +{{must be declared}} expected-error +{{must be defined}}
[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
// 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}}
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
void pre_bfi(B b) { // expected-error +{{must be declared}}
[c++20] Implement P0846R0: allow (ADL-only) calls to template-ids whose template name is not visible to unqualified lookup. In order to support this without a severe degradation in our ability to diagnose typos in template names, this change significantly restructures the way we handle template-id-shaped syntax for which lookup of the template name finds nothing. Instead of eagerly diagnosing an undeclared template name, we now form a placeholder template-name representing a name that is known to not find any templates. When the parser sees such a name, it attempts to disambiguate whether we have a less-than comparison or a template-id. Any diagnostics or typo-correction for the name are delayed until its point of use. The upshot should be a small improvement of our diagostic quality overall: we now take more syntactic context into account when trying to resolve an undeclared identifier on the left hand side of a '<'. In fact, this works well enough that the backwards-compatible portion (for an undeclared identifier rather than a lookup that finds functions but no function templates) is enabled in all language modes. llvm-svn: 360308
2019-05-09 11:31:27 +08:00
b.f<int>();
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
C_Base<1> pre_cb1; // expected-error +{{must be declared}} expected-error +{{must be defined}}
[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}}
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
C1 pre_c1; // expected-error +{{must be declared}}
[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}}
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
C2 pre_c2; // expected-error +{{must be declared}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
D::X pre_dx; // expected-error +{{must be declared}} expected-error +{{must be defined}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
int pre_e = E(0); // expected-error {{must be declared}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
int pre_ff = F<int>().f(); // expected-error +{{must be declared}}
int pre_fg = F<int>().g<int>(); // expected-error +{{must be declared}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
G::A pre_ga // expected-error +{{must be declared}}
= G::a; // expected-error +{{must be declared}}
[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}}
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
decltype(G::h) pre_gh = G::h; // expected-error +{{must be declared}} expected-error +{{must be defined}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
int pre_h = H(); // expected-error +{{must be declared}}
Push alias-declarations and alias-template declarations into scope even if they're redeclarations. This is necessary in order for name lookup to correctly find the most recent declaration of the name (which affects default template argument lookup and cross-module merging, among other things). llvm-svn: 275612
2016-07-16 04:53:25 +08:00
// expected-note@defs.h:56 +{{here}}
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
using pre_i = I<>; // expected-error +{{must be declared}} expected-error +{{default argument of 'I' must be defined}}
Push alias-declarations and alias-template declarations into scope even if they're redeclarations. This is necessary in order for name lookup to correctly find the most recent declaration of the name (which affects default template argument lookup and cross-module merging, among other things). llvm-svn: 275612
2016-07-16 04:53:25 +08:00
// expected-note@defs.h:57 +{{here}}
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
J<> pre_j; // expected-error {{'J' must be declared}}
// expected-error-re@-1 {{missing '#include "{{.*}}.h"'; default argument of 'J' must be defined before it is used}}
[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
Improve diagnostics for missing import / #include of module. Fix a few bugs where we would fail to properly determine header to module correspondence when determining whether to suggest a #include or import, and suggest a #include more often in language modes where there is no import syntax. Generally, if the target is in a header with include guards or #pragma once, we should suggest either #including or importing that header, and not importing a module that happens to textually include it. In passing, improve the notes we attach to the corresponding diagnostics: calling an entity that we couldn't see "previous" is confusing.
2020-04-29 09:22:34 +08:00
ScopedEnum pre_scopedenum; // expected-error {{must be declared}}
[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
// 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;
Push alias-declarations and alias-template declarations into scope even if they're redeclarations. This is necessary in order for name lookup to correctly find the most recent declaration of the name (which affects default template argument lookup and cross-module merging, among other things). llvm-svn: 275612
2016-07-16 04:53:25 +08:00
int post_h = H();
using post_i = I<>;
[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