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/auto-module-import.m

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

102 lines
4.6 KiB
Mathematica
Raw Normal View History

Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
// RUN: rm -rf %t
[Modules] Change private modules rules and warnings We used to advertise private modules to be declared as submodules (Foo.Private). This has proven to not scale well since private headers might carry several dependencies, introducing unwanted content into the main module and often causing dep cycles. Change the canonical way to name it to Foo_Private, forcing private modules as top level ones, and provide warnings under -Wprivate-module to suggest fixes for other private naming. Update documentation to reflect that. rdar://problem/31173501 llvm-svn: 321337
2017-12-22 10:53:30 +08:00
// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -DERRORS
// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -xobjective-c++ %s -verify
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
//
// Test both with and without the declarations that refer to unimported
// entities. For error recovery, those cases implicitly trigger an import.
Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
Introduce an opt-in warning indicating when the compiler is treating an #include/#import as a module import. llvm-svn: 145500
2011-12-01 02:02:36 +08:00
#include <DependsOnModule/DependsOnModule.h> // expected-warning{{treating #include as an import of module 'DependsOnModule'}}
Add an experimental flag -fauto-module-import that automatically turns #include or #import direcctives of framework headers into module imports of the corresponding framework module. llvm-svn: 139860
2011-09-16 06:00:41 +08:00
#ifdef MODULE_H_MACRO
# error MODULE_H_MACRO should have been hidden
#endif
#ifdef DEPENDS_ON_MODULE
# error DEPENDS_ON_MODULE should have been hidden
#endif
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#ifdef ERRORS
Module *mod; // expected-error{{declaration of 'Module' must be imported from module 'Module' before it is required}}
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-note@Inputs/Module.framework/Headers/Module.h:15 {{not visible}}
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#else
Inferred framework modules automatically export anything they import (i.e., 'export *'), to better match the semantics of headers. llvm-svn: 145813
2011-12-06 01:40:25 +08:00
#import <AlsoDependsOnModule/AlsoDependsOnModule.h> // expected-warning{{treating #import as an import of module 'AlsoDependsOnModule'}}
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#endif
Inferred framework modules automatically export anything they import (i.e., 'export *'), to better match the semantics of headers. llvm-svn: 145813
2011-12-06 01:40:25 +08:00
Module *mod2;
When building the main file to parse given a module map, don't skip explicit submodules or umbrella headers from submodules. Instead, build the entire module at once, and let the name-hiding mechanisms hide the contents of explicit submodules at load time. llvm-svn: 145940
2011-12-07 01:15:11 +08:00
int getDependsOther() { return depends_on_module_other; }
When suggesting a module import for a #include or #import, suggest the most specific (sub)module based on the actual file we find, rather than always importing the top-level module. This means that #include'ing <Foo/Blah.h> should give us the submodule Foo.Blah. llvm-svn: 145942
2011-12-07 01:31:28 +08:00
void testSubframeworkOther() {
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#ifdef ERRORS
double *sfo1 = sub_framework_other; // expected-error{{declaration of 'sub_framework_other' must be imported from module 'DependsOnModule.SubFramework.Other'}}
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-note@Inputs/DependsOnModule.framework/Frameworks/SubFramework.framework/Headers/Other.h:15 {{not visible}}
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#endif
When suggesting a module import for a #include or #import, suggest the most specific (sub)module based on the actual file we find, rather than always importing the top-level module. This means that #include'ing <Foo/Blah.h> should give us the submodule Foo.Blah. llvm-svn: 145942
2011-12-07 01:31:28 +08:00
}
Implement the notion of umbrella directories, which implicity cover all of the headers below that particular directory. Use umbrella directories as a clean way to deal with (1) directories/frameworks that don't have an umbrella header, but don't want to enumerate all of their headers, and (2) PrivateHeaders, which we never want to enumerate and want to keep separate from the main umbrella header. This also eliminates a little more of the "magic" for private headers, and frameworks in general. llvm-svn: 146235
2011-12-09 10:04:43 +08:00
// Test umbrella-less submodule includes
#include <NoUmbrella/A.h> // expected-warning{{treating #include as an import of module 'NoUmbrella.A'}}
int getNoUmbrellaA() { return no_umbrella_A; }
When we have an umbrella directory in a module map, recursively walk the subdirectories to find headers in submodules. llvm-svn: 146398
2011-12-13 03:13:53 +08:00
// Test umbrella-less submodule includes
#include <NoUmbrella/SubDir/C.h> // expected-warning{{treating #include as an import of module 'NoUmbrella.SubDir.C'}}
int getNoUmbrellaC() { return no_umbrella_C; }
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#ifndef ERRORS
When suggesting a module import for a #include or #import, suggest the most specific (sub)module based on the actual file we find, rather than always importing the top-level module. This means that #include'ing <Foo/Blah.h> should give us the submodule Foo.Blah. llvm-svn: 145942
2011-12-07 01:31:28 +08:00
// Test header cross-subframework include pattern.
Allow inferred submodules for any (sub)module that has an umbrella header llvm-svn: 145945
2011-12-07 01:34:58 +08:00
#include <DependsOnModule/../Frameworks/SubFramework.framework/Headers/Other.h> // expected-warning{{treating #include as an import of module 'DependsOnModule.SubFramework.Other'}}
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
#endif
When suggesting a module import for a #include or #import, suggest the most specific (sub)module based on the actual file we find, rather than always importing the top-level module. This means that #include'ing <Foo/Blah.h> should give us the submodule Foo.Blah. llvm-svn: 145942
2011-12-07 01:31:28 +08:00
void testSubframeworkOtherAgain() {
double *sfo1 = sub_framework_other;
}
When inferring a module map for a framework, infer subframework modules for each of its subframeworks. llvm-svn: 145957
2011-12-07 03:39:29 +08:00
void testModuleSubFramework() {
char *msf = module_subframework;
}
#include <Module/../Frameworks/SubFramework.framework/Headers/SubFramework.h> // expected-warning{{treating #include as an import of module 'Module.SubFramework'}}
void testModuleSubFrameworkAgain() {
char *msf = module_subframework;
}
Implement basic support for private headers in frameworks. In essence, when we load a module map (module.map) from a directory, also load a private module map (module_private.map) for that directory, if present. That private module map can inject a new submodule that captures private headers. llvm-svn: 146012
2011-12-07 10:23:45 +08:00
// Test inclusion of private headers.
#include <DependsOnModule/DependsOnModulePrivate.h> // expected-warning{{treating #include as an import of module 'DependsOnModule.Private.DependsOnModule'}}
Make sure we pick up module_private.map when loading a module.map file. llvm-svn: 146074
2011-12-08 05:25:07 +08:00
int getDependsOnModulePrivate() { return depends_on_module_private; }
Implement inference for the "Private" submodule corresponding to private headers in a framework. llvm-svn: 146082
2011-12-08 06:05:21 +08:00
Don't infer a submodule for a framework's private header, at least for now. llvm-svn: 148117
2012-01-14 00:54:27 +08:00
#include <Module/ModulePrivate.h> // includes the header
Implement inference for the "Private" submodule corresponding to private headers in a framework. llvm-svn: 146082
2011-12-08 06:05:21 +08:00
int getModulePrivate() { return module_private; }
Implement the notion of umbrella directories, which implicity cover all of the headers below that particular directory. Use umbrella directories as a clean way to deal with (1) directories/frameworks that don't have an umbrella header, but don't want to enumerate all of their headers, and (2) PrivateHeaders, which we never want to enumerate and want to keep separate from the main umbrella header. This also eliminates a little more of the "magic" for private headers, and frameworks in general. llvm-svn: 146235
2011-12-09 10:04:43 +08:00
#include <NoUmbrella/A_Private.h> // expected-warning{{treating #include as an import of module 'NoUmbrella.Private.A_Private'}}
int getNoUmbrellaAPrivate() { return no_umbrella_A_private; }
During typo correction, check for an exact match in an unimported module. If we find one, then report the error as a missing import instead of as a typo. llvm-svn: 188821
2013-08-21 04:35:18 +08:00
int getNoUmbrellaBPrivateFail() { return no_umbrella_B_private; } // expected-error{{declaration of 'no_umbrella_B_private' must be imported from module 'NoUmbrella.Private.B_Private'}}
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-note@Inputs/NoUmbrella.framework/PrivateHeaders/B_Private.h:1 {{not visible}}
Detect when mapping a #include/#import over to a submodule ends up hitting a submodule that was never actually created, e.g., because that header wasn't parsed. In such cases, complain (because the module's umbrella headers don't cover everything) and fall back to including the header. Later, we'll add a warning at module-build time to catch all such cases. However, this fallback is important to eliminate assertions in the ASTWriter when this happens. llvm-svn: 146933
2011-12-20 08:28:52 +08:00
// Test inclusion of headers that are under an umbrella directory but
// not actually part of the module.
#include <Module/NotInModule.h> // expected-warning{{treating #include as an import of module 'Module.NotInModule'}} \
// expected-warning{{missing submodule 'Module.NotInModule'}}
int getNotInModule() {
return not_in_module;
}
When we hit a #include directive that maps to a module import, emit a token representing the module import rather than making the module immediately visible. This serves two goals: * It avoids making declarations in the module visible prematurely, if we walk past the #include during a tentative parse, for instance, and * It gives a diagnostic (although, admittedly, not a very nice one) if a header with a corresponding module is included anywhere other than at the top level. llvm-svn: 194782
2013-11-15 12:24:58 +08:00
[Modules] More descriptive diagnostics for misplaced import directive If an import directive was put into wrong context, the error message was obscure, complaining on misbalanced braces. To get more descriptive messages, annotation tokens related to modules are processed where they must not be seen. Differential Revision: http://reviews.llvm.org/D11844 llvm-svn: 248085
2015-09-19 13:32:57 +08:00
void includeNotAtTopLevel() { // expected-note {{function 'includeNotAtTopLevel' begins here}}
#include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} \
[modules] When a #include is mapped to a module import and appears somewhere other than the top level, we issue an error. This breaks a fair amount of C++ code wrapping C libraries, where the C library is #included within a namespace / extern "C" combination, because the C library (probably) includes C++ standard library headers which may be within modules. Without modules, this setup is harmless if (and *only* if) the corresponding standard library module was already included outside the namespace, so downgrade the error to a default-error extension in that case, so that it can be selectively disabled for such misbehaving libraries. llvm-svn: 253398
2015-11-18 07:32:01 +08:00
expected-error {{redundant #include of module 'NoUmbrella.A' appears within function 'includeNotAtTopLevel'}}
[Modules] More descriptive diagnostics for misplaced import directive If an import directive was put into wrong context, the error message was obscure, complaining on misbalanced braces. To get more descriptive messages, annotation tokens related to modules are processed where they must not be seen. Differential Revision: http://reviews.llvm.org/D11844 llvm-svn: 248085
2015-09-19 13:32:57 +08:00
}
[modules] When a #include is mapped to a module import and appears somewhere other than the top level, we issue an error. This breaks a fair amount of C++ code wrapping C libraries, where the C library is #included within a namespace / extern "C" combination, because the C library (probably) includes C++ standard library headers which may be within modules. Without modules, this setup is harmless if (and *only* if) the corresponding standard library module was already included outside the namespace, so downgrade the error to a default-error extension in that case, so that it can be selectively disabled for such misbehaving libraries. llvm-svn: 253398
2015-11-18 07:32:01 +08:00
#ifdef __cplusplus
namespace NS { // expected-note {{begins here}}
#include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} \
expected-error {{redundant #include of module 'NoUmbrella.A' appears within namespace 'NS'}}
}
extern "C" { // expected-note {{begins here}}
#include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} \
expected-error {{import of C++ module 'NoUmbrella.A' appears within extern "C"}}
}
#endif