[Modules] Don't support clang module and c++20 module at the same time

[ChuanqiXu]

Summary

Background: https://lists.llvm.org/pipermail/cfe-dev/2021-November/069237.html
Simply, we think it is weird to support c++20 module and clang module at the same time.
Further more, there was no way to judge if the compiler was running in clang module instead of c++20 module. Both in clang module and c++20 module, LangOpts::Modules would be true. So it makes it hard to implement c++20 semantics.

Main change in this patch:

• Emit an error if the driver/frontend detect that the input implies that it want to use clang module and c++20 module at the same time.
• Add variable LangOpts::ClangModules. LangOpts::ClangModules would be true only if the user specified -fmodules.
• Remove variable LangOpts::Modules. Add member function LangOpts::hasModules(). Replace all the uses of LangOpts::Modules with LangOpts::hasModules(). LangOpts::hasModules() would return true in case clang modules or c++20 modules are enabled.

And the thing confuses me is the wanted behavior of clang/Modules/ms-enums.cpp. See the inline comments for details.

Another thing Aaron proposed in the mailing list is to rename '-fmodules' to '-fclang-modules'. It sounds good. But this patch didn't contain this change since I think change the command line option may be a break change and need more discussion. Especially clang modules are used broadly.

Test-Plan: check-all (except clang/Modules/ms-enums.cpp)

[tschuett]

This sounds like an enum.

enum class ModuleKind {
C++20,
Clang,
Unsupported
}

[ChuanqiXu]

clang/test/Modules/ms-enums.cpp

1

This test couldn't pass. If we input -std=c++20 -fmodules -fno-cxx-modules, it would output

missing '#include "A.h"'; 'fwd_enum' must be declared before it is used

Instead of the message it wanted.

The secret is in: https://github.com/llvm/llvm-project/blob/99023627010bbfefb71e25a2b4d056de1cbd354e/clang/lib/Lex/PPDirectives.cpp#L788-L793. It tells that even if the compiler couldn't find the header, in the case C++20 modules is required, the compiler shouldn't emit an error for inclusion directly. So the test would fail after we disable the use of C++20 modules.

And I am not sure what we should do here. Should we change the expected error message? In that way the test shouldn't be under Modules. Or should we delete it? It looks not good. And I am wondering what's the intention of this file. It looks like it want to test module maps. But it is not standard c++20 module.

BTW, I have tried to rewrite this test into c++20 module. It looks like:

// A.cpp
export module A;
export enum fwd_enum;
// B.cpp
export module B;
export import A;
// ms-enums.cpp
import B;
...

But it wouldn't emit errors. So I am really not sure what should we do here.

[ChuanqiXu]

In D113391#3115080, @tschuett wrote:

This sounds like an enum.

enum class ModuleKind {
C++20,
Clang,
Unsupported
}

In fact, there is another value ModuleTS. But it looks not bad. And the variable CPlusPlusModules and ClangModules comes from options directly (See Options.td for details). So it looks like we couldn't eliminate CPlusPlusModules and ClangModules after we introduce this enum. So the overall complexity didn't get decreased to me.

[tschuett]

It would enforce that there is exactly one module mode live.

[ChuanqiXu]

Update part in clang-tools-extra

[ChuanqiXu]

In D113391#3115410, @tschuett wrote:

It would enforce that there is exactly one module mode live.

Yeah. But my consideration is that it would enforce another variable and it couldn't eliminate the two existing variables. So it looks redundant to me. We have made this check in driver and frontend part. So it looks sufficient to me.
I admit that the current method has limitations. For example, it is possible that both ClangModules and CPlusPlusModules could be wrote as true in Lexer part and Sema part (Maybe we could add an assertion in hasModules()). And your suggestion could solve this. But I have another question about the implementation, where should we put this variable and when should we fill the value for it? I failed to use a new variable in LangOpts and initialize it in constructor of LangOpts since both ClangModules and CPlusPlusModules is zero.
And even in this suggestion, user could still access ClangModules and CPlusPlusModules. And they could rewrite them too. So I am wondering if it would be more confusing.

[ChuanqiXu]

clang/lib/Driver/ToolChains/Clang.cpp

3445–3447

From our discussion, fmodules shouldn't be suppressed by fno-cxx-modules. And the tests shows that is wouldn't be a problem to relax this.

[jansvoboda11]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

7

Please undo the whitespace changes in ClangScanDeps tests.

9

Can you explain why -fcxx-modules is removed? We want to explicitly enable Clang modules for C++ inputs here. That's off by default in our downstream repo and we'd like to keep this upstream to prevent conflicts. (it's benign upstream)

[ChuanqiXu]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

7

It looks like that it's formatted by clang-format surprisingly. I would undo this manually.

9

According to the discussion in the link, I think it is in consensus that we decide to not support clang modules and c++20 modules at the same time. (I know many people may not have visited it. If any one disagree with the higher idea, I think it would be better to reply in that thread).
So the original test case would fail.

We want to explicitly enable Clang modules for C++ inputs here.

I am not sure if I missed any thing. Personally, it looks like the test now would test clang modules for c++ inputs. Since it has -fmodule option so that clang module is enabled and the input is C++ (from its suffix). Do I misunderstand you?

[jansvoboda11]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

7

Thanks.

9

According to the discussion in the link, I think it is in consensus that we decide to not support clang modules and c++20 modules at the same time. (I know many people may not have visited it. If any one disagree with the higher idea, I think it would be better to reply in that thread).
So the original test case would fail.

What's the error message? As I say, we're enabling Clang modules for C++ input here, not C++20 modules.

We want to explicitly enable Clang modules for C++ inputs here.

I am not sure if I missed any thing. Personally, it looks like the test now would test clang modules for c++ inputs. Since it has -fmodule option so that clang module is enabled and the input is C++ (from its suffix). Do I misunderstand you?

Right. What I'm saying is that in our downstream repo, -fmodules is not enough to enable Clang modules for C++ inputs, you need to do it via -fcxx-modules. And we'd like to keep it upstream, even though it's benign here, to avoid conflicts between the repos.

[MyDeveloperDay]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

7

Just as a drive by assuming you are using a fairly recent clang-format, then clang-format should ONLY clang-format .json files if you have added the following code into your .clang-format

BasedOnStyle: LLVM
ColumnLimit: 0
AlwaysBreakTemplateDeclarations: No
Language: Cpp
---
Language: Json
BasedOnStyle: LLVM

Doing so would render like this

$ clang-format cdb.json
[
  {
    "directory": "DIR",
    "command": "clang -E DIR/header-search-pruning.cpp -Ibegin -I1 -Ia -I3 -I4 -
I5 -I6 -Ib -I8 -Iend DEFINES -fmodules -fcxx-modules -fmodules-cache-path=DIR/mo
dule-cache -fimplicit-modules -fmodule-map-file=DIR/module.modulemap",
    "file": "DIR/header-search-pruning.cpp"
  }
]

[ChuanqiXu]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

7

Oh, thanks for your kindly guide. But I have updated this manually hhh. BTW, the clang-format I am using is:

git diff -U0 --no-color --relative HEAD^ | clang/tools/clang-format/clang-format-diff.py -p1 -i

This one is recommended by the authority documentation so I think many others would use this too.

9

What's the error message? As I say, we're enabling Clang modules for C++ input here, not C++20 modules.

The error message is added in this patch. After this patch landed, the original intentional behavior would be -fmodules to enable clang module and -fcxx-modules to enable C++20 modules.

Right. What I'm saying is that in our downstream repo, -fmodules is not enough to enable Clang modules for C++ inputs, you need to do it via -fcxx-modules. And we'd like to keep it upstream, even though it's benign here, to avoid conflicts between the repos.

Got it. But it conflicts with the idea that disable clang module and c++20 module at the same time. Personally, I think it would be better to edit the code in downstream. @aaron.ballman sorry if I ping you too frequently. But I think now we need input from you.

[ChuanqiXu]

Undo unnecessary style change in *.json files

[jansvoboda11]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

9

Ah, I understand now, thanks for explaining.

I'm worried about changing the behavior of a driver flag, we generally don't break existing driver options. Have you considered keeping the -fmodules and -fcxx-modules semantics intact and instead add new -fno-c++20-modules flag or something like that?

[aaron.ballman]

clang/include/clang/Basic/DiagnosticDriverKinds.td

162–163

I think we can get away with err_drv_argument_not_allowed_with for this diagnostic -- this also will tell the user *which* options are in conflict.

clang/include/clang/Basic/DiagnosticFrontendKinds.td

244

I think it's reasonable to give a diagnostic from the driver when the user does this, but in the FE for a cc1 invocation, I'm a bit less sympathetic to giving people nice diagnostics. Do we need this diagnostic, or can we pick one option to be the "winner" in this case?

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

9

I'm worried about changing the behavior of a driver flag, we generally don't break existing driver options. Have you considered keeping the -fmodules and -fcxx-modules semantics intact and instead add new -fno-c++20-modules flag or something like that?

The goal is not "let users disable C++20 modules", it's "ensure the user cannot enable two different kinds of modules at the same time". What I think we want to avoid is "C++20 mode, but with Clang modules instead of standard modules" or "C++20 mode, but with both clang and standard modules", etc. I think the support matrix that makes sense to me is:

C++20 mode: you get standard modules, no other module schemes are allowed
Pre-C++20 modes: you can opt into Clang modules or you can opt into C++20 modules
Non-C++ modes: you can opt into Clang modules (maybe we want to also support C++20 modules in C, but I'm less certain)

However, I'm not certain if other people agree. I'm basing this on the belief that we don't want modules features to have different semantics within the same program. While this does make it harder for people with a C++17 code base using Clang modules to upgrade to C++20, I suggest that users shouldn't enable -std=c++20 until their code base is ready to make that leap and that includes dealing with the incompatible modules features.

@dblaikie -- I've seen you responding to some of the WG21 discussions around modules. Do you have opinions here?

[dblaikie]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

9

Mixed feelings - it's still a pretty exploratory space.

Backwards compatibility's pretty important - though, yeah, seems some folks on the C++ committee have different ideas about that & insist C++20 presents a pretty hard break in terms of how libraries vend interfaces, etc. Sorry, that's a bit of an aside/only vaguely connected.

I'd /guess/ Google would want some way to combine C++20 and Clang Header Modules if/when we get to the rollout - and Apple's probably in that situation too?

I'm honestly probably a bit too out of the loop to make good calls here - I've weighed in on a few conversations to try to help move them forward here and there where I thought I could add value, but probably not informed enough really.

How far are Clang Header Modules from C++20 header units? Far enough off that we can't just treat things that are Clang Header Modules pre-C++20 as C++20 header units when building in C++20 mode?

[Bigcheese]

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

9

I'd /guess/ Google would want some way to combine C++20 and Clang Header Modules if/when we get to the rollout - and Apple's probably in that situation too?

Very much so. We would like Clang modules to just be modeled as C++20 Header Units, which was a large reason for Header Units existing in the first place.

Specifically module maps are how Clang implements the "set of implementation defined headers" requirement for C++20 Header Units.

[rsmith]

The ideal situation here would be to have a single semantic model that is a superset of the various combinations of behaviors we want. Further entrenching Clang modules and C++20 modules as being different things would be a backwards step, and would be harmful for users of Clang modules who want to incrementally adopt C++20 modules. We shouldn't have a separate language option flag for "clang modules" -- that should be a different kind of module, not a different compilation mode; if a clang header module needs different treatment from a C++20 header unit, we should base that on the kind of the current clang::Module, not on a language option.

In terms of what the various LangOptions flags mean:

LangOptions::Modules corresponds to the expectation that modular headers will be imported rather than entered textually.
LangOptions::ModulesTS enables C++ Modules TS language syntax. This corresponds to -fmodules-ts. We should probably deprecate it.
LangOptions::CPlusPlusModules enables C++20 modules syntax. This is enabled by -std=c++20.
LangOptions::ModulesLocalVisibility indicates that in this compilation, visibility is not monotonically increasing. This corresponds to -fmodules-local-submodule-visibility. This is the case when we might compile multiple source files or header units into a single AST, and we want to reset the visibility state at the end of each such unit. For example, this happens when building a Clang module containing multiple headers. This really should be enabled automatically when appropriate, but for now it's enabled by default with CPlusPlusModules and ModulesTS.

The only combination that's incompatible here is ModulesTS plus CPlusPlusModules, because they have overlapping but different syntax.

[ChuanqiXu]

Oh, OK. If this is not the direction the community want, we might not go on this direction.

clang-tools-extra/clang-tidy/ClangTidy.cpp

ClangTidyASTConsumerFactory::createASTConsumer(
   }
 
   std::unique_ptr<ast_matchers::MatchFinder> Finder(
       new ast_matchers::MatchFinder(std::move(FinderOptions)));
 
   Preprocessor *PP = &Compiler.getPreprocessor();
   Preprocessor *ModuleExpanderPP = PP;
 
-  if (Context.getLangOpts().Modules && OverlayFS != nullptr) {
+  if (Context.getLangOpts().hasModules() && OverlayFS != nullptr) {
     auto ModuleExpander = std::make_unique<ExpandModularHeadersPPCallbacks>(
         &Compiler, OverlayFS);
     ModuleExpanderPP = ModuleExpander->getPreprocessor();
     PP->addPPCallbacks(std::move(ModuleExpander));
   }
 
   for (auto &Check : Checks) {
     Check->registerMatchers(&*Finder);

clang-tools-extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp

: Recorder(std::make_unique<FileRecorder>()), Compiler(*CI),
             new ForwardingDiagnosticConsumer(Compiler.getDiagnosticClient())),
       LangOpts(Compiler.getLangOpts()) {
   // Add a FileSystem containing the extra files needed in place of modular
   // headers.
   OverlayFS->pushOverlay(InMemoryFs);
 
   Diags.setSourceManager(&Sources);
 
-  LangOpts.Modules = false;
+  LangOpts.ClangModules = false;
 
   auto HSO = std::make_shared<HeaderSearchOptions>();
   *HSO = Compiler.getHeaderSearchOpts();
 
   HeaderInfo = std::make_unique<HeaderSearch>(HSO, Sources, Diags, LangOpts,
                                                &Compiler.getTarget());
 
   auto PO = std::make_shared<PreprocessorOptions>();

clang-tools-extra/test/clang-tidy/checkers/bugprone-suspicious-include.cpp

-// RUN: %check_clang_tidy %s bugprone-suspicious-include %t -- -- -isystem %S/Inputs/Headers -fmodules
+// RUN: %check_clang_tidy %s bugprone-suspicious-include %t -- -- -isystem %S/Inputs/Headers
 
 // clang-format off
 
 // CHECK-MESSAGES: [[@LINE+4]]:11: warning: suspicious #include of file with '.cpp' extension
 // CHECK-MESSAGES: [[@LINE+3]]:11: note: did you mean to include 'a'?
 // CHECK-MESSAGES: [[@LINE+2]]:11: note: did you mean to include 'a.h'?
 // CHECK-MESSAGES: [[@LINE+1]]:11: note: did you mean to include 'a.hpp'?
 #include "a.cpp"

clang-tools-extra/test/pp-trace/pp-trace-modules.cpp

 // RUN: rm -rf %t
-// RUN: pp-trace -callbacks '*,-FileChanged,-MacroDefined' %s -- -x objective-c++ -undef -target x86_64 -std=c++11 -fmodules -fcxx-modules -fmodules-cache-path=%t -I%S -I%S/Input | FileCheck --strict-whitespace %s
+// RUN: pp-trace -callbacks '*,-FileChanged,-MacroDefined' %s -- -x objective-c++ -undef -target x86_64 -std=c++11 -fmodules -fmodules-cache-path=%t -I%S -I%S/Input | FileCheck --strict-whitespace %s
 
 // CHECK: ---
 
 @import Level1A;
 
 // CHECK-NEXT: - Callback: moduleImport
 // CHECK-NEXT:   ImportLoc: "{{.*}}{{[/\\]}}pp-trace-modules.cpp:[[@LINE-3]]:2"
 // CHECK-NEXT:   Path: [{Name: Level1A, Loc: "{{.*}}{{[/\\]}}pp-trace-modules.cpp:[[@LINE-4]]:9"}]

clang/include/clang/Basic/DiagnosticDriverKinds.td

 def err_drv_invalid_version_number : Error<
   "invalid version number in '%0'">;
 def err_drv_no_linker_llvm_support : Error<
   "'%0': unable to pass LLVM bit-code files to linker">;
 def err_drv_no_ast_support : Error<
   "'%0': unable to use AST files with this tool">;
 def err_drv_no_module_support : Error<
   "'%0': unable to use module files with this tool">;
+def err_drv_clang_module_cxx_module_conflicts : Error <
+  "Unable to use clang module and c++20 module at the same time.">;
 def err_drv_clang_unsupported : Error<
   "the clang compiler does not support '%0'">;
 def err_drv_clang_unsupported_opt_cxx_darwin_i386 : Error<
   "the clang compiler does not support '%0' for C++ on Darwin/i386">;
 def err_drv_clang_unsupported_opt_pg_darwin: Error<
   "the clang compiler does not support -pg option on %select{Darwin|versions of OS X 10.9 and later}0">;
 def err_drv_clang_unsupported_opt_faltivec : Error<
   "the clang compiler does not support '%0', %1">;

clang/include/clang/Basic/DiagnosticFrontendKinds.td

def remark_module_build : Remark<"building module '%0' as '%1'">,
   InGroup<ModuleBuild>;
 def remark_module_build_done : Remark<"finished building module '%0'">,
   InGroup<ModuleBuild>;
 def remark_module_lock : Remark<"locking '%0' to build module '%1'">,
   InGroup<ModuleLock>;
 def err_modules_embed_file_not_found :
   Error<"file '%0' specified by '-fmodules-embed-file=' not found">,
   DefaultFatal;
+def err_conflicts_clang_module_and_cxx20_module :
+  Error<"Unable to use clang module and c++20 module at the same time.">;
 def err_module_header_file_not_found :
   Error<"module header file '%0' not found">, DefaultFatal;
 
 def err_test_module_file_extension_version : Error<
   "test module file extension '%0' has different version (%1.%2) than expected "
   "(%3.%4)">;
 
 def err_missing_vfs_overlay_file : Error<

clang/include/clang/Basic/Features.def

 FEATURE(objc_arr, LangOpts.ObjCAutoRefCount) // FIXME: REMOVE?
 FEATURE(objc_arc, LangOpts.ObjCAutoRefCount)
 FEATURE(objc_arc_fields, true)
 FEATURE(objc_arc_weak, LangOpts.ObjCWeak)
 FEATURE(objc_default_synthesize_properties, LangOpts.ObjC)
 FEATURE(objc_fixed_enum, LangOpts.ObjC)
 FEATURE(objc_instancetype, LangOpts.ObjC)
 FEATURE(objc_kindof, LangOpts.ObjC)
-FEATURE(objc_modules, LangOpts.ObjC && LangOpts.Modules)
+FEATURE(objc_modules, LangOpts.ObjC && LangOpts.ClangModules)
 FEATURE(objc_nonfragile_abi, LangOpts.ObjCRuntime.isNonFragile())
 FEATURE(objc_property_explicit_atomic, true)
 FEATURE(objc_protocol_qualifier_mangling, true)
 FEATURE(objc_weak_class, LangOpts.ObjCRuntime.hasWeakClassImport())
 FEATURE(ownership_holds, true)
 FEATURE(ownership_returns, true)
 FEATURE(ownership_takes, true)
 FEATURE(objc_bool, true)

 FEATURE(is_pod, LangOpts.CPlusPlus)
 FEATURE(is_polymorphic, LangOpts.CPlusPlus)
 FEATURE(is_sealed, LangOpts.CPlusPlus &&LangOpts.MicrosoftExt)
 FEATURE(is_trivial, LangOpts.CPlusPlus)
 FEATURE(is_trivially_assignable, LangOpts.CPlusPlus)
 FEATURE(is_trivially_constructible, LangOpts.CPlusPlus)
 FEATURE(is_trivially_copyable, LangOpts.CPlusPlus)
 FEATURE(is_union, LangOpts.CPlusPlus)
-FEATURE(modules, LangOpts.Modules)
+FEATURE(modules, LangOpts.hasModules())
 FEATURE(safe_stack, LangOpts.Sanitize.has(SanitizerKind::SafeStack))
 FEATURE(shadow_call_stack,
         LangOpts.Sanitize.has(SanitizerKind::ShadowCallStack))
 FEATURE(tls, PP.getTargetInfo().isTLSSupported())
 FEATURE(underlying_type, LangOpts.CPlusPlus)
 
 // C11 features supported by other languages as extensions.
 EXTENSION(c_alignas, true)

clang/include/clang/Basic/LangOptions.h

bool isCompilingModule() const {
     return getCompilingModule() != CMK_None;
   }
 
   /// Do we need to track the owning module for a local declaration?
   bool trackLocalOwningModule() const {
     return isCompilingModule() || ModulesLocalVisibility;
   }
 
+  /// are clang module or c++20 module (or c++ module ts) enabled?
+  bool hasModules() const {
+    return ClangModules || CPlusPlusModules || ModulesTS;
+  }
+
   bool isSignedOverflowDefined() const {
     return getSignedOverflowBehavior() == SOB_Defined;
   }
 
   bool isSubscriptPointerArithmetic() const {
     return ObjCRuntime.isSubscriptPointerArithmetic() &&
            !ObjCSubscriptingLegacyRuntime;
   }

clang/include/clang/Basic/LangOptions.def

 COMPATIBLE_LANGOPT(RecoveryASTType, 1, 1, "Preserve the type in recovery expressions")
 
 BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers")
 LANGOPT(POSIXThreads      , 1, 0, "POSIX thread support")
 LANGOPT(Blocks            , 1, 0, "blocks extension to C")
 BENIGN_LANGOPT(EmitAllDecls      , 1, 0, "emitting all declarations")
 LANGOPT(MathErrno         , 1, 1, "errno in math functions")
 BENIGN_LANGOPT(HeinousExtensions , 1, 0, "extensions that we really don't like and may be ripped out at any time")
-LANGOPT(Modules           , 1, 0, "modules semantics")
+LANGOPT(ClangModules           , 1, 0, "clang modules semantics")
 COMPATIBLE_LANGOPT(ModulesTS  , 1, 0, "C++ Modules TS syntax")
 COMPATIBLE_LANGOPT(CPlusPlusModules, 1, 0, "C++ modules syntax")
 BENIGN_ENUM_LANGOPT(CompilingModule, CompilingModuleKind, 2, CMK_None,
                     "compiling a module interface")
 BENIGN_LANGOPT(CompilingPCH, 1, 0, "building a pch")
 BENIGN_LANGOPT(BuildingPCHWithObjectFile, 1, 0, "building a pch which has a corresponding object file")
 BENIGN_LANGOPT(CacheGeneratedPCH, 1, 0, "cache generated PCH files in memory")
 BENIGN_LANGOPT(PCHInstantiateTemplates, 1, 0, "instantiate templates while building a PCH")

clang/include/clang/Driver/Options.td

 def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group>,
   Flags<[NoXarchOption, CC1Option, CoreOption]>,
   HelpText<"Implicitly search the file system for module map files.">,
   MarshallingInfoFlag<HeaderSearchOpts<"ImplicitModuleMaps">>;
 def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">,
   MarshallingInfoFlag<LangOpts<"ModulesTS">>;
 defm modules : BoolFOption<"modules",
-  LangOpts<"Modules">, Default<!strconcat(fmodules_ts.KeyPath, "||", fcxx_modules.KeyPath)>,
+  LangOpts<"ClangModules">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Enable the 'modules' language feature">,
   NegFlag<SetFalse>, BothFlags<[NoXarchOption, CoreOption]>>;
 def fmodule_maps : Flag <["-"], "fmodule-maps">, Flags<[CoreOption]>, Alias<fimplicit_module_maps>;
 def fmodule_name_EQ : Joined<["-"], "fmodule-name=">, Group<f_Group>,
   Flags<[NoXarchOption,CC1Option,CoreOption]>, MetaVarName<"<name>">,
   HelpText<"Specify the name of the module to build">,
   MarshallingInfoString<LangOpts<"ModuleName">>;
 def fmodule_implementation_of : Separate<["-"], "fmodule-implementation-of">,

clang/include/clang/Lex/Preprocessor.h

class MacroState {
 
     ModuleMacroInfo *getModuleInfo(Preprocessor &PP,
                                    const IdentifierInfo *II) const {
       if (II->isOutOfDate())
         PP.updateOutOfDateIdentifier(const_cast<IdentifierInfo&>(*II));
       // FIXME: Find a spare bit on IdentifierInfo and store a
       //        HasModuleMacros flag.
       if (!II->hasMacroDefinition() ||
-          (!PP.getLangOpts().Modules &&
+          (!PP.getLangOpts().hasModules() &&
            !PP.getLangOpts().ModulesLocalVisibility) ||
           !PP.CurSubmoduleState->VisibleModules.getGeneration())
         return nullptr;
 
       auto *Info = State.dyn_cast<ModuleMacroInfo*>();
       if (!Info) {
         Info = new (PP.getPreprocessorAllocator())
             ModuleMacroInfo(State.get<MacroDirective *>());
public:
 
   void setPreprocessToken(bool Preprocess) { PreprocessToken = Preprocess; }
 
   bool isMacroDefined(StringRef Id) {
     return isMacroDefined(&Identifiers.get(Id));
   }
   bool isMacroDefined(const IdentifierInfo *II) {
     return II->hasMacroDefinition() &&
-           (!getLangOpts().Modules || (bool)getMacroDefinition(II));
+           (!getLangOpts().hasModules() || (bool)getMacroDefinition(II));
   }
 
   /// Determine whether II is defined as a macro within the module M,
   /// if that is a module that we've already preprocessed. Does not check for
   /// macros imported into M.
   bool isMacroDefinedInLocalModule(const IdentifierInfo *II, Module *M) {
     if (!II->hasMacroDefinition())
       return false;

clang/lib/ARCMigrate/ObjCMT.cpp

bool ObjCMigrateASTConsumer::InsertFoundation(ASTContext &Ctx,
   if (Loc.isInvalid())
     return false;
   auto *nsEnumId = &Ctx.Idents.get("NS_ENUM");
   if (PP.getMacroDefinitionAtLoc(nsEnumId, Loc)) {
     FoundationIncluded = true;
     return true;
   }
   edit::Commit commit(*Editor);
-  if (Ctx.getLangOpts().Modules)
+  if (Ctx.getLangOpts().ClangModules)
     commit.insert(Loc, "#ifndef NS_ENUM\n@import Foundation;\n#endif\n");
   else
     commit.insert(Loc, "#ifndef NS_ENUM\n#import <Foundation/Foundation.h>\n#endif\n");
   Editor->commit(commit);
   FoundationIncluded = true;
   return true;
 }
 

clang/lib/AST/Decl.cpp

 
 EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC,
                            SourceLocation StartLoc, SourceLocation IdLoc,
                            IdentifierInfo *Id,
                            EnumDecl *PrevDecl, bool IsScoped,
                            bool IsScopedUsingClassTag, bool IsFixed) {
   auto *Enum = new (C, DC) EnumDecl(C, DC, StartLoc, IdLoc, Id, PrevDecl,
                                     IsScoped, IsScopedUsingClassTag, IsFixed);
-  Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
+  Enum->setMayHaveOutOfDateDef(C.getLangOpts().hasModules());
   C.getTypeDeclType(Enum, PrevDecl);
   return Enum;
 }
 
 EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   EnumDecl *Enum =
       new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
                            nullptr, nullptr, false, false, false);
-  Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
+  Enum->setMayHaveOutOfDateDef(C.getLangOpts().hasModules());
   return Enum;
 }
 
 SourceRange EnumDecl::getIntegerTypeRange() const {
   if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
     return TI->getTypeLoc().getSourceRange();
   return SourceRange();
 }
RecordDecl::RecordDecl(Kind DK, TagKind TK, const ASTContext &C,
   setArgPassingRestrictions(APK_CanPassInRegs);
 }
 
 RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                                SourceLocation StartLoc, SourceLocation IdLoc,
                                IdentifierInfo *Id, RecordDecl* PrevDecl) {
   RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
                                          StartLoc, IdLoc, Id, PrevDecl);
-  R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
+  R->setMayHaveOutOfDateDef(C.getLangOpts().hasModules());
 
   C.getTypeDeclType(R, PrevDecl);
   return R;
 }
 
 RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
   RecordDecl *R =
       new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
                              SourceLocation(), nullptr, nullptr);
-  R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
+  R->setMayHaveOutOfDateDef(C.getLangOpts().hasModules());
   return R;
 }
 
 bool RecordDecl::isInjectedClassName() const {
   return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
     cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
 }
 

clang/lib/AST/DeclCXX.cpp

 
 CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
                                      DeclContext *DC, SourceLocation StartLoc,
                                      SourceLocation IdLoc, IdentifierInfo *Id,
                                      CXXRecordDecl *PrevDecl,
                                      bool DelayTypeCreation) {
   auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc, IdLoc, Id,
                                       PrevDecl);
-  R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
+  R->setMayHaveOutOfDateDef(C.getLangOpts().hasModules());
 
   // FIXME: DelayTypeCreation seems like such a hack
   if (!DelayTypeCreation)
     C.getTypeDeclType(R, PrevDecl);
   return R;
 }
 
 CXXRecordDecl *

clang/lib/AST/DeclObjC.cpp

ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
                                              IdentifierInfo *Id,
                                              ObjCTypeParamList *typeParamList,
                                              ObjCInterfaceDecl *PrevDecl,
                                              SourceLocation ClassLoc,
                                              bool isInternal){
   auto *Result = new (C, DC)
       ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
                         isInternal);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getLangOpts().ClangModules);
   C.getObjCInterfaceType(Result, PrevDecl);
   return Result;
 }
 
 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
                                                          unsigned ID) {
   auto *Result = new (C, ID)
       ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr,
                         SourceLocation(), nullptr, false);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getLangOpts().ClangModules);
   return Result;
 }
 
 ObjCInterfaceDecl::ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC,
                                      SourceLocation AtLoc, IdentifierInfo *Id,
                                      ObjCTypeParamList *typeParamList,
                                      SourceLocation CLoc,
                                      ObjCInterfaceDecl *PrevDecl,

 
 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
                                            IdentifierInfo *Id,
                                            SourceLocation nameLoc,
                                            SourceLocation atStartLoc,
                                            ObjCProtocolDecl *PrevDecl) {
   auto *Result =
       new (C, DC) ObjCProtocolDecl(C, DC, Id, nameLoc, atStartLoc, PrevDecl);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getLangOpts().ClangModules);
   return Result;
 }
 
 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
   ObjCProtocolDecl *Result =
       new (C, ID) ObjCProtocolDecl(C, nullptr, nullptr, SourceLocation(),
                                    SourceLocation(), nullptr);
-  Result->Data.setInt(!C.getLangOpts().Modules);
+  Result->Data.setInt(!C.getLangOpts().ClangModules);
   return Result;
 }
 
 bool ObjCProtocolDecl::isNonRuntimeProtocol() const {
   return hasAttr<ObjCNonRuntimeProtocolAttr>();
 }
 
 void ObjCProtocolDecl::getImpliedProtocols(

clang/lib/CodeGen/CodeGenModule.cpp

if (LangOpts.Sanitize.has(SanitizerKind::Address) && getTriple().isAMDGPU()) {
     addCompilerUsedGlobal(Var);
   }
 
   emitLLVMUsed();
   if (SanStats)
     SanStats->finish();
 
   if (CodeGenOpts.Autolink &&
-      (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
+      (Context.getLangOpts().hasModules() || !LinkerOptionsMetadata.empty())) {
     EmitModuleLinkOptions();
   }
 
   // On ELF we pass the dependent library specifiers directly to the linker
   // without manipulating them. This is in contrast to other platforms where
   // they are mapped to a specific linker option by the compiler. This
   // difference is a result of the greater variety of ELF linkers and the fact
   // that ELF linkers tend to handle libraries in a more complicated fashion

clang/lib/Driver/ToolChains/Clang.cpp

bool Driver::getDefaultModuleCachePath(SmallVectorImpl<char> &Result) {
   if (llvm::sys::path::cache_directory(Result)) {
     llvm::sys::path::append(Result, "clang");
     llvm::sys::path::append(Result, "ModuleCache");
     return true;
   }
   return false;
 }
 
-static void RenderModulesOptions(Compilation &C, const Driver &D,
+static bool RenderModulesOptions(Compilation &C, const Driver &D,
                                  const ArgList &Args, const InputInfo &Input,
                                  const InputInfo &Output,
-                                 ArgStringList &CmdArgs, bool &HaveModules) {
-  // -fmodules enables the use of precompiled modules (off by default).
-  // Users can pass -fno-cxx-modules to turn off modules support for
-  // C++/Objective-C++ programs.
+                                 ArgStringList &CmdArgs, bool HaveCXXModules) {
+  if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false) &&
+      HaveCXXModules)
+    D.Diag(clang::diag::err_drv_clang_module_cxx_module_conflicts);
+
+  // -fmodules enables the use of clang modules (off by default).
   bool HaveClangModules = false;
   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
-    bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
-                                     options::OPT_fno_cxx_modules, true);
-    if (AllowedInCXX || !types::isCXX(Input.getType())) {
-      CmdArgs.push_back("-fmodules");
-      HaveClangModules = true;
-    }
-  }
 
-  HaveModules |= HaveClangModules;
+  bool HaveModules = HaveCXXModules || HaveClangModules;
   if (Args.hasArg(options::OPT_fmodules_ts)) {
     CmdArgs.push_back("-fmodules-ts");
     HaveModules = true;
   }
 
   // -fmodule-maps enables implicit reading of module map files. By default,
   // this is enabled if we are using Clang's flavor of precompiled modules.
   if (Args.hasFlag(options::OPT_fimplicit_module_maps,
static bool RenderModulesOptions(Compilation &C, const Driver &D,
   }
 
   if (Args.hasFlag(options::OPT_fmodules_validate_system_headers,
                    options::OPT_fno_modules_validate_system_headers,
                    ImplicitModules))
     CmdArgs.push_back("-fmodules-validate-system-headers");
 
   Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation);
+
+  return HaveModules;
 }
 
 static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T,
                                    ArgStringList &CmdArgs) {
   // -fsigned-char is default.
   if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char,
                                      options::OPT_fno_signed_char,
                                      options::OPT_funsigned_char,

 
   if (Args.hasArg(options::OPT_fno_inline))
     CmdArgs.push_back("-fno-inline");
 
   Args.AddLastArg(CmdArgs, options::OPT_finline_functions,
                   options::OPT_finline_hint_functions,
                   options::OPT_fno_inline_functions);
 
+  bool HaveCXXModules = Args.hasFlag(
+      options::OPT_fcxx_modules, options::OPT_fno_cxx_modules,
+      Std && (Std->containsValue("c++2a") || Std->containsValue("c++20") ||
+              Std->containsValue("c++latest")));
+
   // FIXME: Find a better way to determine whether the language has modules
   // support by default, or just assume that all languages do.
   bool HaveModules =
-      Std && (Std->containsValue("c++2a") || Std->containsValue("c++20") ||
-              Std->containsValue("c++latest"));
-  RenderModulesOptions(C, D, Args, Input, Output, CmdArgs, HaveModules);
+      RenderModulesOptions(C, D, Args, Input, Output, CmdArgs, HaveCXXModules);
 
   if (Args.hasFlag(options::OPT_fpch_validate_input_files_content,
                    options::OPT_fno_pch_validate_input_files_content, false))
     CmdArgs.push_back("-fvalidate-ast-input-files-content");
   if (Args.hasFlag(options::OPT_fpch_instantiate_templates,
                    options::OPT_fno_pch_instantiate_templates, false))
     CmdArgs.push_back("-fpch-instantiate-templates");
   if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen,

clang/lib/Frontend/ASTUnit.cpp

if (OverrideMainBuffer) {
     // PCH files are always readable.
     OwnedBuffers.push_back(OverrideMainBuffer.release());
   } else {
     PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
     PreprocessorOpts.PrecompiledPreambleBytes.second = false;
   }
 
   // Disable the preprocessing record if modules are not enabled.
-  if (!Clang->getLangOpts().Modules)
+  if (!Clang->getLangOpts().hasModules())
     PreprocessorOpts.DetailedRecord = false;
 
   std::unique_ptr<SyntaxOnlyAction> Act;
   Act.reset(new SyntaxOnlyAction);
   if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
     if (llvm::Error Err = Act->Execute()) {
       consumeError(std::move(Err)); // FIXME this drops errors on the floor.
     }

clang/lib/Frontend/CompilerInstance.cpp

if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
       PP->getAuxTargetInfo())
     HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
 
   ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
                            PP->getLangOpts(), *HeaderSearchTriple);
 
   PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
 
-  if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules) {
+  if (PP->getLangOpts().hasModules() && PP->getLangOpts().ImplicitModules) {
     std::string ModuleHash = getInvocation().getModuleHash();
     PP->getHeaderSearchInfo().setModuleHash(ModuleHash);
     PP->getHeaderSearchInfo().setModuleCachePath(
         getSpecificModuleCachePath(ModuleHash));
   }
 
   // Handle generating dependencies, if requested.
   const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();

clang/lib/Frontend/FrontendAction.cpp

auto FailureCleanup = llvm::make_scope_exit([&]() {
     CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
     setCurrentInput(FrontendInputFile());
     setCompilerInstance(nullptr);
   });
 
   if (!BeginInvocation(CI))
     return false;
 
+  if (CI.getLangOpts().ClangModules && CI.getLangOpts().CPlusPlusModules)
+    CI.getDiagnostics().Report(
+        diag::err_conflicts_clang_module_and_cxx20_module);
+
   // If we're replaying the build of an AST file, import it and set up
   // the initial state from its build.
   if (ReplayASTFile) {
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics());
 
     // The AST unit populates its own diagnostics engine rather than ours.
     IntrusiveRefCntPtr<DiagnosticsEngine> ASTDiags(
         new DiagnosticsEngine(Diags->getDiagnosticIDs(),
if (!usesPreprocessorOnly()) {
     if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
       // Convert headers to PCH and chain them.
       IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
       source = createChainedIncludesSource(CI, FinalReader);
       if (!source)
         return false;
       CI.setASTReader(static_cast<ASTReader *>(FinalReader.get()));
       CI.getASTContext().setExternalSource(source);
-    } else if (CI.getLangOpts().Modules ||
+    } else if (CI.getLangOpts().hasModules() ||
                !CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
       // Use PCM or PCH.
       assert(hasPCHSupport() && "This action does not have PCH support!");
       ASTDeserializationListener *DeserialListener =
           Consumer->GetASTDeserializationListener();
       bool DeleteDeserialListener = false;
       if (CI.getPreprocessorOpts().DumpDeserializedPCHDecls) {
         DeserialListener = new DeserializedDeclsDumper(DeserialListener,
if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
             CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
             DeserialListener, DeleteDeserialListener);
         if (!CI.getASTContext().getExternalSource())
           return false;
       }
       // If modules are enabled, create the AST reader before creating
       // any builtins, so that all declarations know that they might be
       // extended by an external source.
-      if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
+      if (CI.getLangOpts().hasModules() || !CI.hasASTContext() ||
           !CI.getASTContext().getExternalSource()) {
         CI.createASTReader();
         CI.getASTReader()->setDeserializationListener(DeserialListener,
                                                       DeleteDeserialListener);
       }
     }
 
     CI.setASTConsumer(std::move(Consumer));
     if (!CI.hasASTConsumer())
       return false;
   }
 
   // Initialize built-in info as long as we aren't using an external AST
   // source.
-  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
+  if (CI.getLangOpts().hasModules() || !CI.hasASTContext() ||
       !CI.getASTContext().getExternalSource()) {
     Preprocessor &PP = CI.getPreprocessor();
     PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(),
                                            PP.getLangOpts());
   } else {
     // FIXME: If this is a problem, recover from it by creating a multiplex
     // source.
-    assert((!CI.getLangOpts().Modules || CI.getASTReader()) &&
+    assert((!CI.getLangOpts().hasModules() || CI.getASTReader()) &&
            "modules enabled but created an external source that "
            "doesn't support modules");
   }
 
   // If we were asked to load any module files, do so now.
   for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
     if (!CI.loadModuleFile(ModuleFile))
       return false;

clang/lib/Frontend/FrontendActions.cpp

 
 bool GenerateModuleAction::shouldEraseOutputFiles() {
   return !getCompilerInstance().getFrontendOpts().AllowPCMWithCompilerErrors &&
          ASTFrontendAction::shouldEraseOutputFiles();
 }
 
 bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
     CompilerInstance &CI) {
-  if (!CI.getLangOpts().Modules) {
+  if (!CI.getLangOpts().ClangModules) {
     CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
     return false;
   }
 
   return GenerateModuleAction::BeginSourceFileAction(CI);
 }
 
 std::unique_ptr<raw_pwrite_stream>

 std::unique_ptr<raw_pwrite_stream>
 GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
                                                 StringRef InFile) {
   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
 }
 
 bool GenerateHeaderModuleAction::PrepareToExecuteAction(
     CompilerInstance &CI) {
-  if (!CI.getLangOpts().Modules) {
+  if (!CI.getLangOpts().hasModules()) {
     CI.getDiagnostics().Report(diag::err_header_module_requires_modules);
     return false;
   }
 
   auto &Inputs = CI.getFrontendOpts().Inputs;
   if (Inputs.empty())
     return GenerateModuleAction::BeginInvocation(CI);
 

clang/lib/Lex/PPDirectives.cpp

default:
     case tok::pp_assert:
       //isExtension = true;  // FIXME: implement #assert
       break;
     case tok::pp_unassert:
       //isExtension = true;  // FIXME: implement #unassert
       break;
 
     case tok::pp___public_macro:
-      if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)
+      if (getLangOpts().hasModules() || getLangOpts().ModulesLocalVisibility)
         return HandleMacroPublicDirective(Result);
       break;
 
     case tok::pp___private_macro:
-      if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)
+      if (getLangOpts().hasModules() || getLangOpts().ModulesLocalVisibility)
         return HandleMacroPrivateDirective();
       break;
     }
     break;
   }
 
   // If this is a .S file, treat unknown # directives as non-preprocessor
   // directives.  This is important because # may be a comment or introduce
Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(
   // reaching the max allowed include depth again.
   if (Action == Enter && HasReachedMaxIncludeDepth && File &&
       HeaderInfo.getFileInfo(&File->getFileEntry()).NumIncludes)
     Action = IncludeLimitReached;
 
   // Determine whether we should try to import the module for this #include, if
   // there is one. Don't do so if precompiled module support is disabled or we
   // are processing this module textually (because we're building the module).
-  if (Action == Enter && File && SuggestedModule && getLangOpts().Modules &&
+  if (Action == Enter && File && SuggestedModule &&
+      getLangOpts().hasModules() &&
       !isForModuleBuilding(SuggestedModule.getModule(),
                            getLangOpts().CurrentModule,
                            getLangOpts().ModuleName)) {
     // If this include corresponds to a module but that module is
     // unavailable, diagnose the situation and bail out.
     // FIXME: Remove this; loadModule does the same check (but produces
     // slightly worse diagnostics).
     if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), getDiagnostics(),
Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(
   bool EnterOnce =
       IsImportDecl ||
       IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import;
 
   // Ask HeaderInfo if we should enter this #include file.  If not, #including
   // this file will have no effect.
   if (Action == Enter && File &&
       !HeaderInfo.ShouldEnterIncludeFile(*this, &File->getFileEntry(),
-                                         EnterOnce, getLangOpts().Modules,
+                                         EnterOnce, getLangOpts().hasModules(),
                                          SuggestedModule.getModule())) {
     // Even if we've already preprocessed this header once and know that we
     // don't need to see its contents again, we still need to import it if it's
     // modular because we might not have imported it from this submodule before.
     //
     // FIXME: We don't do this when compiling a PCH because the AST
     // serialization layer can't cope with it. This means we get local
     // submodule visibility semantics wrong in that case.

clang/lib/Lex/Preprocessor.cpp

bool Preprocessor::HandleIdentifier(Token &Identifier) {
   // Note that we do not treat 'import' as a contextual
   // keyword when we're in a caching lexer, because caching lexers only get
   // used in contexts where import declarations are disallowed.
   //
   // Likewise if this is the C++ Modules TS import keyword.
   if (((LastTokenWasAt && II.isModulesImport()) ||
        Identifier.is(tok::kw_import)) &&
       !InMacroArgs && !DisableMacroExpansion &&
-      (getLangOpts().Modules || getLangOpts().DebuggerSupport) &&
+      (getLangOpts().hasModules() || getLangOpts().DebuggerSupport) &&
       CurLexerKind != CLK_CachingLexer) {
     ModuleImportLoc = Identifier.getLocation();
     ModuleImportPath.clear();
     ModuleImportExpectsIdentifier = true;
     CurLexerKind = CLK_LexAfterModuleImport;
   }
   return true;
 }
if (getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) {
     }
     SourceLocation FirstPathLoc = ModuleImportPath[0].second;
     ModuleImportPath.clear();
     ModuleImportPath.push_back(
         std::make_pair(getIdentifierInfo(FlatModuleName), FirstPathLoc));
   }
 
   Module *Imported = nullptr;
-  if (getLangOpts().Modules) {
+  if (getLangOpts().hasModules()) {
     Imported = TheModuleLoader.loadModule(ModuleImportLoc,
                                           ModuleImportPath,
                                           Module::Hidden,
                                           /*IsInclusionDirective=*/false);
     if (Imported)
       makeModuleVisible(Imported, SemiLoc);
   }
   if (Callbacks)

clang/lib/Parse/ParseObjc.cpp

case tok::objc_compatibility_alias:
     break;
   case tok::objc_synthesize:
     SingleDecl = ParseObjCPropertySynthesize(AtLoc);
     break;
   case tok::objc_dynamic:
     SingleDecl = ParseObjCPropertyDynamic(AtLoc);
     break;
   case tok::objc_import:
-    if (getLangOpts().Modules || getLangOpts().DebuggerSupport) {
+    if (getLangOpts().hasModules() || getLangOpts().DebuggerSupport) {
       SingleDecl = ParseModuleImport(AtLoc);
       break;
     }
     Diag(AtLoc, diag::err_atimport);
     SkipUntil(tok::semi);
     return Actions.ConvertDeclToDeclGroup(nullptr);
   default:
     Diag(AtLoc, diag::err_unexpected_at);

clang/lib/Sema/SemaCodeComplete.cpp

if (Path.empty()) {
     for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
       Builder.AddTypedTextChunk(
           Builder.getAllocator().CopyString(Modules[I]->Name));
       Results.AddResult(Result(
           Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
           Modules[I]->isAvailable() ? CXAvailability_Available
                                     : CXAvailability_NotAvailable));
     }
-  } else if (getLangOpts().Modules) {
+  } else if (getLangOpts().hasModules()) {
     // Load the named module.
     Module *Mod =
         PP.getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
                                         /*IsInclusionDirective=*/false);
     // Enumerate submodules.
     if (Mod) {
       for (Module::submodule_iterator Sub = Mod->submodule_begin(),
                                       SubEnd = Mod->submodule_end();
static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
   Builder.AddTypedTextChunk(
       OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias"));
   Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
   Builder.AddPlaceholderChunk("alias");
   Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
   Builder.AddPlaceholderChunk("class");
   Results.AddResult(Result(Builder.TakeString()));
 
-  if (Results.getSema().getLangOpts().Modules) {
+  if (Results.getSema().getLangOpts().hasModules()) {
     // @import name
     Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
     Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
     Builder.AddPlaceholderChunk("module");
     Results.AddResult(Result(Builder.TakeString()));
   }
 }
 

clang/lib/Sema/SemaDecl.cpp

 /// Typedef declarations don't have linkage, but they still denote the same
 /// entity if their types are the same.
 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's
 /// isSameEntity.
 static void filterNonConflictingPreviousTypedefDecls(Sema &S,
                                                      TypedefNameDecl *Decl,
                                                      LookupResult &Previous) {
   // This is only interesting when modules are enabled.
-  if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
+  if (!S.getLangOpts().hasModules() && !S.getLangOpts().ModulesLocalVisibility)
     return;
 
   // Empty sets are uninteresting.
   if (Previous.empty())
     return;
 
   LookupResult::Filter Filter = Previous.makeFilter();
   while (Filter.hasNext()) {
if (getLangOpts().CPlusPlus) {
 
     Diag(New->getLocation(), diag::err_redefinition)
       << New->getDeclName();
     notePreviousDefinition(Old, New->getLocation());
     return New->setInvalidDecl();
   }
 
   // Modules always permit redefinition of typedefs, as does C11.
-  if (getLangOpts().Modules || getLangOpts().C11)
+  if (getLangOpts().hasModules() || getLangOpts().C11)
     return;
 
   // If we have a redefinition of a typedef in C, emit a warning.  This warning
   // is normally mapped to an error, but can be controlled with
   // -Wtypedef-redefinition.  If either the original or the redefinition is
   // in a system header, don't emit this for compatibility with GCC.
   if (getDiagnostics().getSuppressSystemWarnings() &&
       // Some standard types are defined implicitly in Clang (e.g. OpenCL).
EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
   }
 
   return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
                                   Val, EnumVal);
 }
 
 Sema::SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
                                                 SourceLocation IILoc) {
-  if (!(getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) ||
+  if (!(getLangOpts().hasModules() || getLangOpts().ModulesLocalVisibility) ||
       !getLangOpts().CPlusPlus)
     return SkipBodyInfo();
 
   // We have an anonymous enum definition. Look up the first enumerator to
   // determine if we should merge the definition with an existing one and
   // skip the body.
   NamedDecl *PrevDecl = LookupSingleName(S, II, IILoc, LookupOrdinaryName,
                                          forRedeclarationInCurContext());

clang/lib/Sema/SemaDeclObjC.cpp

if (ObjCProtocolDecl *Def = PrevDecl? PrevDecl->getDefinition() : nullptr) {
     // That way, we'll end up completely ignoring the duplicate.
     // FIXME: Can we turn this into an error?
     PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
                                      ProtocolLoc, AtProtoInterfaceLoc,
                                      /*PrevDecl=*/nullptr);
 
     // If we are using modules, add the decl to the context in order to
     // serialize something meaningful.
-    if (getLangOpts().Modules)
+    if (getLangOpts().ClangModules)
       PushOnScopeChains(PDecl, TUScope);
     PDecl->startDefinition();
   } else {
     if (PrevDecl) {
       // Check for circular dependencies among protocol declarations. This can
       // only happen if this protocol was forward-declared.
       ObjCList<ObjCProtocolDecl> PList;
       PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);

clang/lib/Sema/SemaLookup.cpp

std::unique_ptr<TypoCorrectionConsumer> Sema::makeTypoCorrectionConsumer(
   // some files to take minutes to get rejected by the parser.
   unsigned Limit = getDiagnostics().getDiagnosticOptions().SpellCheckingLimit;
   if (Limit && TyposCorrected >= Limit)
     return nullptr;
   ++TyposCorrected;
 
   // If we're handling a missing symbol error, using modules, and the
   // special search all modules option is used, look for a missing import.
-  if (ErrorRecovery && getLangOpts().Modules &&
+  if (ErrorRecovery && getLangOpts().hasModules() &&
       getLangOpts().ModulesSearchAll) {
     // The following has the side effect of loading the missing module.
     getModuleLoader().lookupMissingImports(Typo->getName(),
                                            TypoName.getBeginLoc());
   }
 
   // Extend the lifetime of the callback. We delayed this until here
   // to avoid allocations in the hot path (which is where no typo correction
void Sema::diagnoseTypo(const TypoCorrection &Correction,
   std::string CorrectedQuotedStr = Correction.getQuoted(getLangOpts());
   FixItHint FixTypo = FixItHint::CreateReplacement(
       Correction.getCorrectionRange(), CorrectedStr);
 
   // Maybe we're just missing a module import.
   if (Correction.requiresImport()) {
     NamedDecl *Decl = Correction.getFoundDecl();
     assert(Decl && "import required but no declaration to import");
-
     diagnoseMissingImport(Correction.getCorrectionRange().getBegin(), Decl,
                           MissingImportKind::Declaration, ErrorRecovery);
     return;
   }
 
   Diag(Correction.getCorrectionRange().getBegin(), TypoDiag)
     << CorrectedQuotedStr << (ErrorRecovery ? FixTypo : FixItHint());
 

clang/lib/Sema/SemaTemplate.cpp

       if (!S.hasVisibleMemberSpecialization(TD, &Modules))
         diagnose(TD->getMostRecentDecl(), false);
     }
   }
 };
 } // end anonymous namespace
 
 void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
-  if (!getLangOpts().Modules)
+  if (!getLangOpts().hasModules())
     return;
 
   ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
 }

clang/lib/Sema/SemaType.cpp

 ///        in order to provide a definition of this entity.
 /// \param OnlyNeedComplete If \c true, we only need the type to be complete,
 ///        not defined. This only matters for enums with a fixed underlying
 ///        type, since in all other cases, a type is complete if and only if it
 ///        is defined.
 bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
                                 bool OnlyNeedComplete) {
   // Easy case: if we don't have modules, all declarations are visible.
-  if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility)
+  if (!getLangOpts().hasModules() && !getLangOpts().ModulesLocalVisibility)
     return true;
 
   // If this definition was instantiated from a template, map back to the
   // pattern from which it was instantiated.
   if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
     // We're in the middle of defining it; this definition should be treated
     // as visible.
     return true;

clang/lib/Serialization/ASTReader.cpp

static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
   if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
     if (Diags) {
       Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
     }
     return true;
   }
 
   // Detailed record is important since it is used for the module cache hash.
-  if (LangOpts.Modules &&
+  if (LangOpts.hasModules() &&
       PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
     if (Diags) {
       Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
     }
     return true;
   }
 
   // Compute the #include and #include_macros lines we need.

 ///
 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                      StringRef SpecificModuleCachePath,
                                      StringRef ExistingModuleCachePath,
                                      DiagnosticsEngine *Diags,
                                      const LangOptions &LangOpts,
                                      const PreprocessorOptions &PPOpts) {
-  if (LangOpts.Modules) {
+  if (LangOpts.hasModules()) {
     if (SpecificModuleCachePath != ExistingModuleCachePath &&
         !PPOpts.AllowPCHWithDifferentModulesCachePath) {
       if (Diags)
         Diags->Report(diag::err_pch_modulecache_mismatch)
           << SpecificModuleCachePath << ExistingModuleCachePath;
       return true;
     }
   }
bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
   // lookup table until we're done with recursive deserialization.
   auto *Data = (const unsigned char*)Blob.data();
   PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
   return false;
 }
 
 void ASTReader::Error(StringRef Msg) const {
   Error(diag::err_fe_pch_malformed, Msg);
-  if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
+  if (PP.getLangOpts().hasModules() && !Diags.isDiagnosticInFlight() &&
       !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
     Diag(diag::note_module_cache_path)
       << PP.getHeaderSearchInfo().getModuleCachePath();
   }
 }
 
 void ASTReader::Error(unsigned DiagID, StringRef Arg1, StringRef Arg2,
                       StringRef Arg3) const {

 
 } // namespace
 
 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
   // Note that we are loading an identifier.
   Deserializing AnIdentifier(this);
 
   unsigned PriorGeneration = 0;
-  if (getContext().getLangOpts().Modules)
+  if (getContext().getLangOpts().hasModules())
     PriorGeneration = IdentifierGeneration[&II];
 
   // If there is a global index, look there first to determine which modules
   // provably do not have any results for this identifier.
   GlobalModuleIndex::HitSet Hits;
   GlobalModuleIndex::HitSet *HitsPtr = nullptr;
   if (!loadGlobalIndex()) {
     if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {

 
 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
   if (!II)
     return;
 
   II->setOutOfDate(false);
 
   // Update the generation for this identifier.
-  if (getContext().getLangOpts().Modules)
+  if (getContext().getLangOpts().hasModules())
     IdentifierGeneration[II] = getGeneration();
 }
 
 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
                                     const PendingMacroInfo &PMInfo) {
   ModuleFile &M = *PMInfo.M;
 
   BitstreamCursor &Cursor = M.MacroCursor;
void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
   }
 }
 
 bool ASTReader::loadGlobalIndex() {
   if (GlobalIndex)
     return false;
 
   if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
-      !PP.getLangOpts().Modules)
+      !PP.getLangOpts().hasModules())
     return true;
 
   // Try to load the global index.
   TriedLoadingGlobalIndex = true;
   StringRef ModuleCachePath
     = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
   std::pair<GlobalModuleIndex *, llvm::Error> Result =
       GlobalModuleIndex::readIndex(ModuleCachePath);
   if (llvm::Error Err = std::move(Result.second)) {
     assert(!Result.first);
     consumeError(std::move(Err)); // FIXME this drops errors on the floor.
     return true;
   }
 
   GlobalIndex.reset(Result.first);
   ModuleMgr.setGlobalIndex(GlobalIndex.get());
   return false;
 }
 
 bool ASTReader::isGlobalIndexUnavailable() const {
-  return PP.getLangOpts().Modules && UseGlobalIndex &&
-         !hasGlobalIndex() && TriedLoadingGlobalIndex;
+  return PP.getLangOpts().hasModules() && UseGlobalIndex && !hasGlobalIndex() &&
+         TriedLoadingGlobalIndex;
 }
 
 static void updateModuleTimestamp(ModuleFile &MF) {
   // Overwrite the timestamp file contents so that file's mtime changes.
   std::string TimestampFilename = MF.getTimestampFilename();
   std::error_code EC;
   llvm::raw_fd_ostream OS(TimestampFilename, EC,
                           llvm::sys::fs::OF_TextWithCRLF);
ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
 
   unsigned NumModules = ModuleMgr.size();
   SmallVector<ImportedModule, 4> Loaded;
   if (ASTReadResult ReadResult =
           ReadASTCore(FileName, Type, ImportLoc,
                       /*ImportedBy=*/nullptr, Loaded, 0, 0, ASTFileSignature(),
                       ClientLoadCapabilities)) {
     ModuleMgr.removeModules(ModuleMgr.begin() + NumModules,
-                            PP.getLangOpts().Modules
+                            PP.getLangOpts().hasModules()
                                 ? &PP.getHeaderSearchInfo().getModuleMap()
                                 : nullptr);
 
     // If we find that any modules are unusable, the global index is going
     // to be out-of-date. Just remove it.
     GlobalIndex.reset();
     ModuleMgr.setGlobalIndex(nullptr);
     return ReadResult;
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
       // special members may or may not have been implicitly defined).
       if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
         if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
           continue;
 
       // FIXME: Check for =delete/=default?
       // FIXME: Complain about ODR violations here?
       const FunctionDecl *Defn = nullptr;
-      if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
+      if (!getContext().getLangOpts().hasModules() || !FD->hasBody(Defn)) {
         FD->setLazyBody(PB->second);
       } else {
         auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
         mergeDefinitionVisibility(NonConstDefn, FD);
 
         if (!FD->isLateTemplateParsed() &&
             !NonConstDefn->isLateTemplateParsed() &&
             FD->getODRHash() != NonConstDefn->getODRHash()) {
           if (!isa<CXXMethodDecl>(FD)) {
             PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
           } else if (FD->getLexicalParent()->isFileContext() &&
                      NonConstDefn->getLexicalParent()->isFileContext()) {
             // Only diagnose out-of-line method definitions.  If they are
             // in class definitions, then an error will be generated when
             // processing the class bodies.
             PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
           }
         }
       }
       continue;
     }
 
     ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
-    if (!getContext().getLangOpts().Modules || !MD->hasBody())
+    if (!getContext().getLangOpts().hasModules() || !MD->hasBody())
       MD->setLazyBody(PB->second);
   }
   PendingBodies.clear();
 
   // Do some cleanup.
   for (auto *ND : PendingMergedDefinitionsToDeduplicate)
     getContext().deduplicateMergedDefinitonsFor(ND);
   PendingMergedDefinitionsToDeduplicate.clear();

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
   ED->setFixed(Record.readInt());
 
   ED->setHasODRHash(true);
   ED->ODRHash = Record.readInt();
 
   // If this is a definition subject to the ODR, and we already have a
   // definition, merge this one into it.
   if (ED->isCompleteDefinition() &&
-      Reader.getContext().getLangOpts().Modules &&
+      Reader.getContext().getLangOpts().hasModules() &&
       Reader.getContext().getLangOpts().CPlusPlus) {
     EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
     if (!OldDef) {
       // This is the first time we've seen an imported definition. Look for a
       // local definition before deciding that we are the first definition.
       for (auto *D : merged_redecls(ED->getCanonicalDecl())) {
         if (!D->isFromASTFile() && D->isCompleteDefinition()) {
           OldDef = D;
if (FD->isCanonicalDecl()) { // if canonical add to template's set.
       FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);
       void *InsertPos = nullptr;
       FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
       FunctionTemplateSpecializationInfo *ExistingInfo =
           CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
       if (InsertPos)
         CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
       else {
-        assert(Reader.getContext().getLangOpts().Modules &&
+        assert(Reader.getContext().getLangOpts().hasModules() &&
                "already deserialized this template specialization");
         mergeRedeclarable(FD, ExistingInfo->getFunction(), Redecl);
       }
     }
     break;
   }
   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
     // Templates.

 
 /// Attempts to merge the given declaration (D) with another declaration
 /// of the same entity.
 template<typename T>
 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
                                       RedeclarableResult &Redecl,
                                       DeclID TemplatePatternID) {
   // If modules are not available, there is no reason to perform this merge.
-  if (!Reader.getContext().getLangOpts().Modules)
+  if (!Reader.getContext().getLangOpts().hasModules())
     return;
 
   // If we're not the canonical declaration, we don't need to merge.
   if (!DBase->isFirstDecl())
     return;
 
   auto *D = static_cast<T *>(DBase);
 
if (isa<EnumConstantDecl, FieldDecl, IndirectFieldDecl>(ND))
     return true;
   return false;
 }
 
 /// Attempts to merge LifetimeExtendedTemporaryDecl with
 /// identical class definitions from two different modules.
 void ASTDeclReader::mergeMergeable(LifetimeExtendedTemporaryDecl *D) {
   // If modules are not available, there is no reason to perform this merge.
-  if (!Reader.getContext().getLangOpts().Modules)
+  if (!Reader.getContext().getLangOpts().hasModules())
     return;
 
   LifetimeExtendedTemporaryDecl *LETDecl = D;
 
   LifetimeExtendedTemporaryDecl *&LookupResult =
       Reader.LETemporaryForMerging[std::make_pair(
           LETDecl->getExtendingDecl(), LETDecl->getManglingNumber())];
   if (LookupResult)
     Reader.getContext().setPrimaryMergedDecl(LETDecl,
                                              LookupResult->getCanonicalDecl());
   else
     LookupResult = LETDecl;
 }
 
 /// Attempts to merge the given declaration (D) with another declaration
 /// of the same entity, for the case where the entity is not actually
 /// redeclarable. This happens, for instance, when merging the fields of
 /// identical class definitions from two different modules.
 template<typename T>
 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
   // If modules are not available, there is no reason to perform this merge.
-  if (!Reader.getContext().getLangOpts().Modules)
+  if (!Reader.getContext().getLangOpts().hasModules())
     return;
 
   // ODR-based merging is performed in C++ and in some cases (tag types) in C.
   // Note that C identically-named things in different translation units are
   // not redeclarations, but may still have compatible types, where ODR-like
   // semantics may apply.
   if (!Reader.getContext().getLangOpts().CPlusPlus &&
       !allowODRLikeMergeInC(dyn_cast<NamedDecl>(static_cast<T*>(D))))

clang/lib/Serialization/ASTWriter.cpp

if (!OutputFile.empty() && OutputFile != "-") {
     StringRef origDir = llvm::sys::path::parent_path(OutputPath);
 
     RecordData::value_type Record[] = {ORIGINAL_PCH_DIR};
     Stream.EmitRecordWithBlob(AbbrevCode, Record, origDir);
   }
 
   WriteInputFiles(Context.SourceMgr,
                   PP.getHeaderSearchInfo().getHeaderSearchOpts(),
-                  PP.getLangOpts().Modules);
+                  PP.getLangOpts().hasModules());
   Stream.ExitBlock();
 }
 
 namespace  {
 
 /// An input file.
 struct InputFileEntry {
   const FileEntry *File;

 
 /// Determine the declaration that should be put into the name lookup table to
 /// represent the given declaration in this module. This is usually D itself,
 /// but if D was imported and merged into a local declaration, we want the most
 /// recent local declaration instead. The chosen declaration will be the most
 /// recent declaration in any module that imports this one.
 static NamedDecl *getDeclForLocalLookup(const LangOptions &LangOpts,
                                         NamedDecl *D) {
-  if (!LangOpts.Modules || !D->isFromASTFile())
+  if (!LangOpts.hasModules() || !D->isFromASTFile())
     return D;
 
   if (Decl *Redecl = D->getPreviousDecl()) {
     // For Redeclarable decls, a prior declaration might be local.
     for (; Redecl; Redecl = Redecl->getPreviousDecl()) {
       // If we find a local decl, we're done.
       if (!Redecl->isFromASTFile()) {
         // Exception: in very rare cases (for injected-class-names), not all

clang/test/ClangScanDeps/Inputs/header-search-pruning/cdb.json

 [
   {
     "directory": "DIR",
-    "command": "clang -E DIR/header-search-pruning.cpp -Ibegin -I1 -Ia -I3 -I4 -I5 -I6 -Ib -I8 -Iend DEFINES -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fmodule-map-file=DIR/module.modulemap",
+    "command": "clang -E DIR/header-search-pruning.cpp -Ibegin -I1 -Ia -I3 -I4 -I5 -I6 -Ib -I8 -Iend DEFINES -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fmodule-map-file=DIR/module.modulemap",
     "file": "DIR/header-search-pruning.cpp"
   }
 ]

clang/test/ClangScanDeps/Inputs/module_fmodule_name_cdb.json

 [
 {
   "directory": "DIR",
-  "command": "clang -E DIR/modules-fmodule-name-no-module-built.m -IInputs -D INCLUDE_HEADER2 -MD -MF DIR/modules_cdb.d -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fmodule-name=header3 -fimplicit-module-maps",
+  "command": "clang -E DIR/modules-fmodule-name-no-module-built.m -IInputs -D INCLUDE_HEADER2 -MD -MF DIR/modules_cdb.d -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fmodule-name=header3 -fimplicit-module-maps",
   "file": "DIR/modules-fmodule-name-no-module-built.m"
 }
 ]

clang/test/ClangScanDeps/Inputs/modules_cdb.json

 [
 {
   "directory": "DIR",
-  "command": "clang -E DIR/modules_cdb_input2.cpp -IInputs -D INCLUDE_HEADER2 -MD -MF DIR/modules_cdb2.d -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps",
+  "command": "clang -E DIR/modules_cdb_input2.cpp -IInputs -D INCLUDE_HEADER2 -MD -MF DIR/modules_cdb2.d -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps",
   "file": "DIR/modules_cdb_input2.cpp"
 },
 {
   "directory": "DIR",
-  "command": "clang -E DIR/modules_cdb_input.cpp -IInputs -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps",
+  "command": "clang -E DIR/modules_cdb_input.cpp -IInputs -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps",
   "file": "DIR/modules_cdb_input.cpp"
 },
 {
   "directory": "DIR",
-  "command": "clang -E DIR/modules_cdb_input.cpp -IInputs -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -o a.o",
+  "command": "clang -E DIR/modules_cdb_input.cpp -IInputs -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -o a.o",
   "file": "DIR/modules_cdb_input.cpp"
 },
 {
   "directory": "DIR",
-  "command": "clang -E DIR/modules_cdb_input.cpp -IInputs -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -o b.o",
+  "command": "clang -E DIR/modules_cdb_input.cpp -IInputs -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -o b.o",
   "file": "DIR/modules_cdb_input.cpp"
 }
 ]

clang/test/ClangScanDeps/Inputs/modules_cdb_by_mod_name.json

 [
 {
   "directory": "DIR",
-  "command": "clang -E -IInputs -D INCLUDE_HEADER2 -MD -MF DIR/modules_cdb2.d -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -gmodules -x c++",
+  "command": "clang -E -IInputs -D INCLUDE_HEADER2 -MD -MF DIR/modules_cdb2.d -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -gmodules -x c++",
   "file": ""
 },
 {
   "directory": "DIR",
-  "command": "clang -E -IInputs -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -x c++",
+  "command": "clang -E -IInputs -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -x c++",
   "file": ""
 },
 ]

clang/test/ClangScanDeps/Inputs/modules_cdb_clangcl.json

 [
 {
   "directory": "DIR",
-  "command": "clang-cl /E /IInputs /D INCLUDE_HEADER2 /clang:-MD /clang:-MF /clang:DIR/modules_cdb2_clangcl.d /clang:-fmodules /clang:-fcxx-modules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -- DIR/modules_cdb_input2.cpp",
+  "command": "clang-cl /E /IInputs /D INCLUDE_HEADER2 /clang:-MD /clang:-MF /clang:DIR/modules_cdb2_clangcl.d /clang:-fmodules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -- DIR/modules_cdb_input2.cpp",
   "file": "DIR/modules_cdb_input2.cpp"
 },
 {
   "directory": "DIR",
-  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fcxx-modules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -- DIR/modules_cdb_input.cpp",
+  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -- DIR/modules_cdb_input.cpp",
   "file": "DIR/modules_cdb_input.cpp"
 },
 {
   "directory": "DIR",
-  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fcxx-modules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -o a.o -- DIR/modules_cdb_input.cpp",
+  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -o a.o -- DIR/modules_cdb_input.cpp",
   "file": "DIR/modules_cdb_input.cpp"
 },
 {
   "directory": "DIR",
-  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fcxx-modules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -o b.o -- DIR/modules_cdb_input.cpp",
+  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps -o b.o -- DIR/modules_cdb_input.cpp",
   "file": "DIR/modules_cdb_input.cpp"
 }
 ]

clang/test/ClangScanDeps/Inputs/modules_cdb_clangcl_by_mod_name.json

 [
 {
   "directory": "DIR",
-  "command": "clang-cl /E /IInputs /D INCLUDE_HEADER2 /clang:-MD /clang:-MF /clang:DIR/modules_cdb2_clangcl.d /clang:-fmodules /clang:-fcxx-modules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps /clang:-x /clang:c++ --",
+  "command": "clang-cl /E /IInputs /D INCLUDE_HEADER2 /clang:-MD /clang:-MF /clang:DIR/modules_cdb2_clangcl.d /clang:-fmodules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps /clang:-x /clang:c++ --",
   "file": ""
 },
 {
   "directory": "DIR",
-  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fcxx-modules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps /clang:-x /clang:c++ --",
+  "command": "clang-cl /E /IInputs /clang:-fmodules /clang:-fmodules-cache-path=DIR/module-cache_clangcl /clang:-fimplicit-modules /clang:-fimplicit-module-maps /clang:-x /clang:c++ --",
   "file": ""
 },
 ]

clang/test/ClangScanDeps/Inputs/modules_inferred_cdb.json

 [
 {
   "directory": "DIR",
-  "command": "clang -E DIR/modules_cdb_input.cpp -FFRAMEWORKS -fmodules -fcxx-modules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -pedantic -Werror",
+  "command": "clang -E DIR/modules_cdb_input.cpp -FFRAMEWORKS -fmodules -fmodules-cache-path=DIR/module-cache -fimplicit-modules -fimplicit-module-maps -pedantic -Werror",
   "file": "DIR/modules_cdb_input.cpp"
 }
 ]

clang/test/Driver/conflict-clang-module-and-cxx20-module.cpp

+// RUN: %clangxx -### -c %s -std=c++20 -fmodules 2>&1 | FileCheck %s
+// RUN: %clangxx -### -c %s -std=c++2a -fmodules 2>&1 | FileCheck %s
+// RUN: %clangxx -### -c %s -std=c++20 -fmodules -fno-cxx-modules 2>&1 | FileCheck %s --check-prefix=FINE
+// RUN: %clangxx -### -c %s -fcxx-modules -fmodules -fcxx-modules 2>&1 | FileCheck %s
+
+// CHECK: error: Unable to use clang module and c++20 module at the same time.
+// FINE-NOT: error: Unable to use clang module and c++20 module at the same time.

clang/test/Driver/modules.mm

 // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
-// RUN: %clang -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
-// RUN: %clang -fmodules -fno-cxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MODULES %s
+// RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-CLANG-MODULES %s
+// RUN: %clang -fmodules -fno-cxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-CLANG-MODULES %s
 // CHECK-NO-MODULES-NOT: -fmodules
+// CHECK-HAS-CLANG-MODULES: -fmodules
 
-// RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s
-// RUN: %clang -fmodules -fno-cxx-modules -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MODULES %s
-// CHECK-HAS-MODULES: -fmodules
+// RUN: %clang -fmodules -fcxx-modules -fcxx-modules -### %s 2>&1 | FileCheck -check-prefix=CHECK-CONFLICT %s
+// CHECK-CONFLICT: error
 
 // RUN: %clang -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s
 // RUN: %clang -fimplicit-module-maps -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s
 // RUN: %clang -fmodules -### %s 2>&1 | FileCheck -check-prefix=CHECK-HAS-MAPS %s
 // RUN: %clang -fmodules -fno-implicit-module-maps -### %s 2>&1 | FileCheck -check-prefix=CHECK-NO-MAPS %s
 // CHECK-HAS-MAPS: -fimplicit-module-maps
 // CHECK-NO-MAPS-NOT: -fimplicit-module-maps

clang/test/Modules/cxx20.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x c++ -std=c++20 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/cxx20 %s -verify -fno-modules-error-recovery
+// RUN: %clang_cc1 -x c++ -std=c++20 -fmodules-cache-path=%t -fmodules -fno-cxx-modules -fimplicit-module-maps -I %S/Inputs/cxx20 %s -verify -fno-modules-error-recovery
 
 // expected-no-diagnostics
 
 #include "decls.h"
 
 namespace StructuredBinding {
   struct R { int x, y; };
   static auto [a, b] = R();
 }

clang/test/Modules/ms-enums.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-extensions -fms-compatibility -x c++ -std=c++20 -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/ms-enums %s -verify -fno-modules-error-recovery
+// RUN: %clang_cc1 -triple x86_64-windows-msvc -fms-extensions -fms-compatibility -x c++ -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/ms-enums %s -verify -fno-modules-error-recovery
 
 #include "B.h"
 // expected-note@A.h:1 {{declaration here is not visible}}
 // expected-note@A.h:1 2{{definition here is not reachable}}
 
 fwd_enum gv_enum; // expected-error {{must be imported}}
 
 struct Foo {
   enum fwd_enum enum_field; // expected-error 2 {{must be imported}}
 };

clang/test/SemaCXX/compare-modules-cxx2a.cpp

-// RUN: %clang_cc1 -triple x86_64-apple-darwin -fcxx-exceptions -verify -std=c++2a -fmodules -I%S/Inputs %s -fno-modules-error-recovery
+// RUN: %clang_cc1 -triple x86_64-apple-darwin -fcxx-exceptions -verify -std=c++2a -fmodules -fno-cxx-modules -I%S/Inputs %s -fno-modules-error-recovery
 
 #pragma clang module build compare
 module compare {
   explicit module cmp {}
   explicit module other {}
 }
 #pragma clang module contents
 #pragma clang module begin compare.cmp

clang/tools/libclang/Indexing.cpp

if (requestedToGetTU) {
     CacheCodeCompletionResults
       = TU_options & CXTranslationUnit_CacheCompletionResults;
   }
 
   if (TU_options & CXTranslationUnit_DetailedPreprocessingRecord) {
     PPOpts.DetailedRecord = true;
   }
 
-  if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)
+  if (!requestedToGetTU && !CInvok->getLangOpts()->hasModules())
     PPOpts.DetailedRecord = false;
 
   // Unless the user specified that they want the preamble on the first parse
   // set it up to be created on the first reparse. This makes the first parse
   // faster, trading for a slower (first) reparse.
   unsigned PrecompilePreambleAfterNParses =
       !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
   DiagnosticErrorTrap DiagTrap(*Diags);