[C++20][Modules][4/8] Handle generation of partition implementation CMIs.

[iains]

Summary

Partition implementations are special, they generate a CMI, but it
does not have an 'export' line, and we cannot export anything from the
it [that is it can only make decls available to other members of the
owning module, not to importers of that].

[iains]

rebased onto import state machine

[iains]

Rebased onto other modules work.

[iains]

Update formatting

[iains]

this is the fourth patch of eight to implement basic C++20 module partition support.

[iains]

rebased onto changes in parent patches.

[urnathan]

with the assert fixed

clang/lib/Sema/SemaModule.cpp

123

llvm::unreachable ("how did we get a partition type set?");

clang/test/Modules/cxx20-10-1-ex1.cpp

22

I think I'm getting used to this idiom, or maybe Stockholm has kicked in?

[ChuanqiXu]

clang/test/Modules/cxx20-10-1-ex1.cpp

8–9

In my implementation, I replace ':' to '-' in pcm filename. I do so since I remember this is the behavior of GCC. I think '-' is better than '_' since '_' is possible to occur in name.

And I am surprised that the compiler wouldn't complain about that it couldn't find the corresponding pcm. Since I don't see corresponding code so far.

[iains]

address review comments, rebase

clang/test/Modules/cxx20-10-1-ex1.cpp

8–9

The filename could/should be completely decoupled from the module name; changing the filenames to something randomly chosen should make no difference to the tests passing.

I made a comment on why/how this works in 3/8 in reply a similar comment made there (essentially the pairing of module-name and filename is something known by the lmodule loader and/or the header search mechanisms - it is not something that Sema needs to know).

22

we are all hostage to some style decisions made by others?
FAOD, the idiom is not my device, I plagiarised ...

[iains]

fix a typo

[iains]

rebased

[iains]

rebased, revised testcases to use split-file.

clang/include/clang/Sema/Sema.h

Decl *ActOnFileScopeAsmDecl(Expr *expr,
                               SourceLocation AsmLoc,
                               SourceLocation RParenLoc);
 
   /// Handle a C++11 empty-declaration and attribute-declaration.
   Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,
                               SourceLocation SemiLoc);
 
   enum class ModuleDeclKind {
-    Interface,      ///< 'export module X;'
-    Implementation, ///< 'module X;'
+    Interface,               ///< 'export module X;'
+    Implementation,          ///< 'module X;'
+    PartitionInterface,      ///< 'export module X:Y;'
+    PartitionImplementation, ///< 'module X:Y;'
   };
 
   /// An enumeration to represent the transition of states in parsing module
   /// fragments and imports.  If we are not parsing a C++20 TU, or we find
   /// an error in state transition, the state is set to NotACXX20Module.
   enum class ModuleImportState {
     FirstDecl,       ///< Parsing the first decl in a TU.
     GlobalFragment,  ///< after 'module;' but before 'module X;'

clang/lib/Sema/SemaModule.cpp

assert((getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) &&
          "should only have module decl in Modules TS or C++20");
 
   bool IsFirstDecl = ImportState == ModuleImportState::FirstDecl;
   bool SeenGMF = ImportState == ModuleImportState::GlobalFragment;
   // If any of the steps here fail, we count that as invalidating C++20
   // module state;
   ImportState = ModuleImportState::NotACXX20Module;
 
-  // A module implementation unit requires that we are not compiling a module
-  // of any kind. A module interface unit requires that we are not compiling a
-  // module map.
+  bool IsPartition = !Partition.empty();
+  if (IsPartition)
+    switch (MDK) {
+    case ModuleDeclKind::Implementation:
+      MDK = ModuleDeclKind::PartitionImplementation;
+      break;
+    case ModuleDeclKind::Interface:
+      MDK = ModuleDeclKind::PartitionInterface;
+      break;
+    default:
+      llvm_unreachable("how did we get a partition type set?");
+    }
+
+  // A (non-partition) module implementation unit requires that we are not
+  // compiling a module of any kind.  A partition implementation emits an
+  // interface (and the AST for the implementation), which will subsequently
+  // be consumed to emit a binary.
+  // A module interface unit requires that we are not compiling a module map.
   switch (getLangOpts().getCompilingModule()) {
   case LangOptions::CMK_None:
     // It's OK to compile a module interface as a normal translation unit.
     break;
 
   case LangOptions::CMK_ModuleInterface:
     if (MDK != ModuleDeclKind::Implementation)
       break;
 
     // We were asked to compile a module interface unit but this is a module
-    // implementation unit. That indicates the 'export' is missing.
+    // implementation unit.
     Diag(ModuleLoc, diag::err_module_interface_implementation_mismatch)
       << FixItHint::CreateInsertion(ModuleLoc, "export ");
     MDK = ModuleDeclKind::Interface;
     break;
 
   case LangOptions::CMK_ModuleMap:
     Diag(ModuleLoc, diag::err_module_decl_in_module_map_module);
     return nullptr;
if (BeginLoc.isValid()) {
           << FixItHint::CreateInsertion(BeginLoc, "module;\n");
     }
   }
 
   // Flatten the dots in a module name. Unlike Clang's hierarchical module map
   // modules, the dots here are just another character that can appear in a
   // module name.
   std::string ModuleName = stringFromPath(Path);
-  bool IsPartition = !Partition.empty();
   if (IsPartition) {
     ModuleName += ":";
     ModuleName += stringFromPath(Partition);
   }
   // If a module name was explicitly specified on the command line, it must be
   // correct.
   if (!getLangOpts().CurrentModule.empty() &&
       getLangOpts().CurrentModule != ModuleName) {
     Diag(Path.front().second, diag::err_current_module_name_mismatch)
         << SourceRange(Path.front().second, IsPartition
                                                 ? Partition.back().second
                                                 : Path.back().second)
         << getLangOpts().CurrentModule;
     return nullptr;
   }
   const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
 
   auto &Map = PP.getHeaderSearchInfo().getModuleMap();
   Module *Mod;
 
   switch (MDK) {
-  case ModuleDeclKind::Interface: {
+  case ModuleDeclKind::Interface:
+  case ModuleDeclKind::PartitionInterface: {
     // We can't have parsed or imported a definition of this module or parsed a
     // module map defining it already.
     if (auto *M = Map.findModule(ModuleName)) {
       Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;
       if (M->DefinitionLoc.isValid())
         Diag(M->DefinitionLoc, diag::note_prev_module_definition);
       else if (Optional<FileEntryRef> FE = M->getASTFile())
         Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)
             << FE->getName();
       Mod = M;
       break;
     }
 
     // Create a Module for the module that we're defining.
     Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
                                            GlobalModuleFragment);
-    if (IsPartition)
+    if (MDK == ModuleDeclKind::PartitionInterface)
       Mod->Kind = Module::ModulePartitionInterface;
     assert(Mod && "module creation should not fail");
     break;
   }
 
-  case ModuleDeclKind::Implementation:
+  case ModuleDeclKind::Implementation: {
     std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
         PP.getIdentifierInfo(ModuleName), Path[0].second);
-    if (IsPartition) {
-      // Create an interface, but note that it is an implementation
-      // unit.
-      Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
-                                             GlobalModuleFragment);
-      Mod->Kind = Module::ModulePartitionImplementation;
-    } else {
-      // C++20 A module-declaration that contains neither an export-
-      // keyword nor a module-partition implicitly imports the primary
-      // module interface unit of the module as if by a module-import-
-      // declaration.
-      Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},
-                                         Module::AllVisible,
-                                         /*IsInclusionDirective=*/false);
-      if (!Mod) {
-        Diag(ModuleLoc, diag::err_module_not_defined) << ModuleName;
-        // Create an empty module interface unit for error recovery.
-        Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
-                                               GlobalModuleFragment);
-      }
-    }
+  } break;
+
+  case ModuleDeclKind::PartitionImplementation:
+    // Create an interface, but note that it is an implementation
+    // unit.
+    Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
+                                           GlobalModuleFragment);
+    Mod->Kind = Module::ModulePartitionImplementation;
     break;
   }
 
   if (!GlobalModuleFragment) {
     ModuleScopes.push_back({});
     if (getLangOpts().ModulesLocalVisibility)
       ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
   } else {
     // We're done with the global module fragment now.
     ActOnEndOfTranslationUnitFragment(TUFragmentKind::Global);
   }
 
   // Switch from the global module fragment (if any) to the named module.
   ModuleScopes.back().BeginLoc = StartLoc;
   ModuleScopes.back().Module = Mod;
-  ModuleScopes.back().ModuleInterface =
-      (MDK != ModuleDeclKind::Implementation || IsPartition);
+  ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
   ModuleScopes.back().IsPartition = IsPartition;
   VisibleModules.setVisible(Mod, ModuleLoc);
 
   // From now on, we have an owning module for all declarations we see.
   // However, those declarations are module-private unless explicitly
   // exported.
   auto *TU = Context.getTranslationUnitDecl();
   TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);

clang/test/Modules/cxx20-10-1-ex1.cpp

+// The example in the standard is not in required build order.
+// revised here
+
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex1-tu1.cpp \
+// RUN:  -o %t/A_Internals.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex1-tu2.cpp \
+// RUN:  -fmodule-file=%t/A_Internals.pcm -o %t/A_Foo.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex1-tu3.cpp \
+// RUN:  -fmodule-file=%t/A_Foo.pcm -o %t/A.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-obj %t/std10-1-ex1-tu4.cpp \
+// RUN:  -fmodule-file=%t/A.pcm -o %t/ex1.o
+
+// expected-no-diagnostics
+
+//--- std10-1-ex1-tu1.cpp
+
+module A:Internals;
+int bar();
+
+//--- std10-1-ex1-tu2.cpp
+
+export module A:Foo;
+
+import :Internals;
+
+export int foo() { return 2 * (bar() + 1); }
+
+//--- std10-1-ex1-tu3.cpp
+
+export module A;
+export import :Foo;
+export int baz();
+
+//--- std10-1-ex1-tu4.cpp
+
+module A;
+
+import :Internals;
+
+int bar() { return baz() - 10; }
+int baz() { return 30; }

clang/test/Modules/cxx20-10-1-ex2.cpp

+
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex2-tu1.cpp \
+// RUN:  -o %t/B_Y.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex2-tu2.cpp \
+// RUN:  -fmodule-file=%t/B_Y.pcm -o %t/B.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex2-tu3.cpp \
+// RUN:   -o %t/B_X1.pcm -verify
+
+// Not expected to work yet.
+//  %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex2-tu4.cpp \
+//   -fmodule-file=%t/B.pcm  -o %t/B_X2.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-obj %t/std10-1-ex2-tu5.cpp \
+// RUN:  -fmodule-file=%t/B.pcm  -o %t/b_tu5.o
+
+// RUN: %clang_cc1 -std=c++20 -S %t/std10-1-ex2-tu6.cpp \
+// RUN:  -fmodule-file=%t/B.pcm  -o %t/b_tu6.s -verify
+
+// Not expected to work yet.
+//  %clang_cc1 -std=c++20 -emit-module-interface %t/std10-1-ex2-tu7.cpp \
+//   -fmodule-file=%t/B_X2.pcm  -o %t/B_X3.pcm -verify
+
+//--- std10-1-ex2-tu1.cpp
+module B:Y;
+int y();
+// expected-no-diagnostics
+
+//--- std10-1-ex2-tu2.cpp
+export module B;
+import :Y;
+int n = y();
+// expected-no-diagnostics
+
+//--- std10-1-ex2-tu3.cpp
+module B:X1; // does not implicitly import B
+int &a = n;  // expected-error {{use of undeclared identifier }}
+
+//--- std10-1-ex2-tu4.cpp
+module B:X2; // does not implicitly import B
+import B;
+int &b = n; // OK
+// expected-no-diagnostics
+
+//--- std10-1-ex2-tu5.cpp
+module B;   // implicitly imports B
+int &c = n; // OK
+// expected-no-diagnostics
+
+//--- std10-1-ex2-tu6.cpp
+import B;
+// error, n is module-local and this is not a module.
+int &c = n; // expected-error {{use of undeclared identifier}}
+
+//--- std10-1-ex2-tu7.cpp
+module B:X3; // does not implicitly import B
+import :X2;  // X2 is an implementation so exports nothing.
+             // error: n not visible here.
+int &c = n;  // expected-error {{use of undeclared identifier }}

clang/test/Modules/cxx20-import-diagnostics-a.cpp

 
 int foo () { return 10; }
 
 import C; // expected-error {{imports must immediately follow the module declaration}}
 
 //--- import-diags-tu7.cpp
 
 module;
-// We can only have preprocessor commands here, which could include an include
+// We can only have preprocessor directives here, which permits an include-
 // translated header unit.  However those are identified specifically by the
-// preprocessor; non-preprocessed user code should not contain an import here.
+// preprocessor; non-preprocessed user code should not contain an 'import' here.
 import B; // expected-error {{module imports cannot be in the global module fragment}}
 
 export module D;
 
 int delta ();
 
 //--- import-diags-tu8.cpp