[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?

517–518

???

520

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).

517–518

thanks, will remove this.

520

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

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++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;
   }
 
   /// Does this Module scope describe a fragment of the global module within
   /// some C++ module.
   bool isGlobalModule() const { return Kind == GlobalModuleFragment; }
 
 private:
   /// The submodules of this module, indexed by name.
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.
+  bool isModulePartition() 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

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.
     // FIXME: p1815 removes the need for this distinction -- there are no

clang/lib/Sema/SemaModule.cpp

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

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...