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

89 lines
3.8 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] 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 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -DERRORS
// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %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}}
// expected-note@Inputs/Module.framework/Headers/Module.h:15 {{previous}}
#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'}}
// expected-note@Inputs/DependsOnModule.framework/Frameworks/SubFramework.framework/Headers/Other.h:15 {{previous}}
#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'}}
// expected-note@Inputs/NoUmbrella.framework/PrivateHeaders/B_Private.h:1 {{previous}}
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
Generate a marker token when entering or leaving a submodule when building a module. Use the marker to diagnose cases where we try to transition between submodules when not at the top level (most likely because a closing brace was missing at the end of a header file, but is also possible if submodule headers attempt to do something fundamentally non-modular, like our .def files). llvm-svn: 195543
2013-11-23 12:06:09 +08:00
void includeNotAtTopLevel() { // expected-note {{to match this '{'}}
#include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} expected-error {{expected '}'}}
} // expected-error {{extraneous closing brace}}