[C++20][Modules][2/8] Add enumerations for partition modules and stream them.

[iains]

Summary

This is an initial enabling patch for module partition support.
We add enumerations for partition interfaces/implementations.
This means that the module kind enumeration now occupies three
bits, so the AST streamer is adjusted for this. Adding one bit there
seems preferable to trying to overload the meanings of existing
kinds (and we will also want to add a C++20 header unit case later).

[iains]

Rebased, moved an unreleated change to a later patch.

[iains]

Rebased onto D118893

[iains]

Rebased onto other modules work

[iains]

address formatting issues.

not sure why these showed up now and not in previous rebases...

[iains]

this is the second in an 8 patch series to implement basic C++20 module partition support - here we add module types for partitions (and work on header units will add an additional enumeration in a subsequent series).

[urnathan]

clang/include/clang/Basic/Module.h

109

I think it's confusing to continue to refer to modules-ts modules at this point. Is that really necessary?
The specific confusion here is that does 'ModuleInterfaceUnit' mean one of two different things depending on compilation mode, or is it a single thing with two different names?

514–515

???

517

isModulePartition?

[iains]

clang/include/clang/Basic/Module.h

109

In this case, I re-used the enumeration since the modules-ts / c++20 modules are disambiguated by the -fmodules-ts flag.

So, yes, the enum value does have two uses depending on compilation mode. I can amend the comment to try and make this clear, would that help?

I have been trying not to regress anything for modules-ts (and certainly for clang modules) - if someone makes a decision to retire modules-ts then there is probably a bunch of simplification that could be made.

With the extra bit to represent the enumeration, we have more space so we *could* have different names for the modules-ts/C++20 interfaces (although I suspect that will just make more code at the use sites, and would prefer not to go down that route).

514–515

thanks, will remove this.

517

works for me, will do.

[urnathan]

clang/include/clang/Basic/Module.h

109

IMHO 'modules-ts' is not a useful thing distinct from 'c++20 modules'. The semantics of the TS itself were unclear or broken in places, and only resolved once things got into the std (via 1103/Atom). I think the semantics of '-fmodules-ts' should be the module-specific semantics of C++20 as applied to whatever version of the std being selected (and I'd be fine making it Buyer-Beware for anything before C++20 anyway).

But, if you don't want to bite that bullet right now, a clarifying note would be helpful.

[iains]

address review comments

[iains]

clang/include/clang/Basic/Module.h

109

I think we can just go with C++20 and as you suggest treat the TS as a dialect.

[urnathan]

lgtm

[ChuanqiXu]

LGTM

[iains]

rebased onto changes in parent patches.

[urnathan]

please remind me when this is committed that I'll need to adjust D118352 -- at the moment that's searching for ':' to determine partitionness

[iains]

rebased

clang/include/clang/Basic/Module.h

 //===- Module.h - Describe a module -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   /// The location of the module definition.
   SourceLocation DefinitionLoc;
 
   enum ModuleKind {
     /// This is a module that was defined by a module map and built out
     /// of header files.
     ModuleMapModule,
 
-    /// This is a C++ Modules TS module interface unit.
+    /// This is a C++ Modules TS or C++20 module interface unit.
     ModuleInterfaceUnit,
 
+    /// This is a C++ 20 module partition interface.
+    ModulePartitionInterface,
+
+    /// This is a C++ 20 module partition implementation.
+    ModulePartitionImplementation,
+
     /// This is a fragment of the global module within some C++ module.
     GlobalModuleFragment,
 
     /// This is the private module fragment within some C++ module.
     PrivateModuleFragment,
   };
 
   /// The kind of this module.
public:
   std::string UmbrellaRelativeToRootModuleDirectory;
 
   /// The module through which entities defined in this module will
   /// eventually be exposed, for use in "private" modules.
   std::string ExportAsModule;
 
   /// Does this Module scope describe part of the purview of a named C++ module?
   bool isModulePurview() const {
-    return Kind == ModuleInterfaceUnit || Kind == PrivateModuleFragment;
+    return Kind == ModuleInterfaceUnit ||
+           Kind == ModulePartitionInterface ||
+           Kind == ModulePartitionImplementation ||
+           Kind == PrivateModuleFragment;
   }
 
 private:
   /// The submodules of this module, indexed by name.
   std::vector<Module *> SubModules;
 
   /// A mapping from the submodule name to the index into the
   /// \c SubModules vector at which that submodule resides.
public:
   /// could not be set during module creation.
   void setParent(Module *M) {
     assert(!Parent);
     Parent = M;
     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
     Parent->SubModules.push_back(this);
   }
 
+  /// Is this a module partition.
+  /// ??? : make a bit and stream it?
+
+  bool isPartition() const {
+    return Name.find(':') != std::string::npos;
+  }
+
   /// Retrieve the full name of this module, including the path from
   /// its top-level module.
   /// \param AllowStringLiterals If \c true, components that might not be
   ///        lexically valid as identifiers will be emitted as string literals.
   std::string getFullModuleName(bool AllowStringLiterals = false) const;
 
   /// Whether the full name of this module is equal to joining
   /// \p nameParts with "."s.

clang/lib/AST/Decl.cpp

 //===- Decl.cpp - Declaration AST Node Implementation ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (!M)
     return nullptr;
 
   switch (M->Kind) {
   case Module::ModuleMapModule:
     // Module map modules have no special linkage semantics.
     return nullptr;
 
   case Module::ModuleInterfaceUnit:
+  case Module::ModulePartitionInterface:
+  case Module::ModulePartitionImplementation:
     return M;
 
   case Module::GlobalModuleFragment: {
     // External linkage declarations in the global module have no owning module
     // for linkage purposes. But internal linkage declarations in the global
     // module fragment of a particular module are owned by that module for
     // linkage purposes.
     if (IgnoreLinkage)

clang/lib/Basic/Module.cpp

 //===- Module.cpp - Describe a module -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
   // just look there?
   for (const Module *Current = this; Current; Current = Current->Parent) {
     if (!Current->MissingHeaders.empty()) {
       MissingHeader = Current->MissingHeaders.front();
       return false;
     }
   }
 
+  if (Kind == Module::ModulePartitionImplementation)
+    return false;
+
   llvm_unreachable("could not find a reason why module is unavailable");
 }
 
 bool Module::isSubModuleOf(const Module *Other) const {
   for (auto *Parent = this; Parent; Parent = Parent->Parent) {
     if (Parent == Other)
       return true;
   }

clang/lib/Sema/SemaModule.cpp

 //===--- SemaModule.cpp - Semantic Analysis for Modules -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
                                      SourceLocation PrivateLoc) {
   // C++20 [basic.link]/2:
   //   A private-module-fragment shall appear only in a primary module
   //   interface unit.
   switch (ModuleScopes.empty() ? Module::GlobalModuleFragment
                                : ModuleScopes.back().Module->Kind) {
   case Module::ModuleMapModule:
   case Module::GlobalModuleFragment:
+  case Module::ModulePartitionImplementation:
+  case Module::ModulePartitionInterface:
     Diag(PrivateLoc, diag::err_private_module_fragment_not_module);
     return nullptr;
 
   case Module::PrivateModuleFragment:
     Diag(PrivateLoc, diag::err_private_module_fragment_redefined);
     Diag(ModuleScopes.back().BeginLoc, diag::note_previous_definition);
     return nullptr;
 

clang/lib/Serialization/ASTWriter.cpp

 //===- ASTWriter.cpp - AST File Writer ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void ASTWriter::WriteSubmodules(Module *WritingModule) {
 
   // Write the abbreviations needed for the submodules block.
   using namespace llvm;
 
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(SUBMODULE_DEFINITION));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ID
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Parent
-  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Kind
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Kind
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFramework
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExplicit
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsSystem
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsExternC
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferSubmodules...
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExplicit...
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InferExportWild...
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ConfigMacrosExh...