[C++20][Modules]5/8] Diagnose wrong import/export for partition CMIs.

[iains]

Fix whitespace error.

[iains]

rebased onto import state machine.

[iains]

re-apply rebase

[iains]

Rebased onto other modules work.

[iains]

update formatting.

[iains]

patch 5 of 8 to implement basic C++20 module partition support.

[iains]

rebased onto changes in parent commits.

[ChuanqiXu]

LGTM with the name about partition CMI addressed (It is raised in previous patch)

[iains]

rebased onto changes in parent patches

[iains]

rebased

[iains]

rebased, revised testcases to use split-file.

[iains]

rebased

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_module_import_not_at_top_level_fatal : Error<
   "import of module '%0' appears within %1">, DefaultFatal;
 def ext_module_import_not_at_top_level_noop : ExtWarn<
   "redundant #include of module '%0' appears within %1">, DefaultError,
   InGroup<DiagGroup<"modules-import-nested-redundant">>;
 def note_module_import_not_at_top_level : Note<"%0 begins here">;
 def err_module_self_import : Error<
   "import of module '%0' appears within same top-level module '%1'">;
+def err_module_self_import_cxx20 : Error<
+  "import of module '%0' appears within its own %select{interface|implementation}1">;
 def err_module_import_in_implementation : Error<
   "@import of module '%0' in implementation of '%1'; use #import">;
 
 // C++ Modules
 def err_module_decl_not_at_start : Error<
   "module declaration must occur at the start of the translation unit">;
 def note_global_module_introducer_missing : Note<
   "add 'module;' to the start of the file to introduce a "
def err_export_within_export : Error<
   "export declaration appears within another export declaration">;
 def err_export_internal : Error<
   "declaration of %0 with internal linkage cannot be exported">;
 def err_export_using_internal : Error<
   "using declaration referring to %0 with internal linkage cannot be exported">;
 def err_export_not_in_module_interface : Error<
   "export declaration can only be used within a module interface unit"
   "%select{ after the module declaration|}0">;
+def err_export_partition_impl : Error<
+  "module partition implementations cannot be exported">;
 def err_export_in_private_module_fragment : Error<
   "export declaration cannot be used in a private module fragment">;
 def note_private_module_fragment : Note<
   "private module fragment begins here">;
 def err_private_module_fragment_not_module : Error<
   "private module fragment declaration with no preceding module declaration">;
 def err_private_module_fragment_redefined : Error<
   "private module fragment redefined">;

clang/lib/Sema/SemaModule.cpp

if (IsPartition) {
     Partition = ModuleIdPath(ModuleNameLoc);
   } else if (Cxx20Mode) {
     ModuleName = stringFromPath(NamePath);
     ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), NamePath[0].second};
     NamePath = ModuleIdPath(ModuleNameLoc);
   }
 
   // Diagnose self-import before attempting a load.
+  // [module.import]/9
+  // A module implementation unit of a module M that is not a module partition
+  // shall not contain a module-import-declaration nominating M.
+  // (for an implementation, the module interface is imported implicitly,
+  //  but that's handled in the module decl code).
+
   if (getLangOpts().CPlusPlusModules && isCurrentModulePurview() &&
       getCurrentModule()->Name == ModuleName) {
-    Diag(ImportLoc, diag::err_module_self_import) << ModuleName
-      << getLangOpts().CurrentModule;
+    Diag(ImportLoc, diag::err_module_self_import_cxx20) << ModuleName
+         << !ModuleScopes.back().ModuleInterface;
     return true;
   }
 
   Module *Mod =
       getModuleLoader().loadModule(ImportLoc,
                                    IsPartition ? Partition : NamePath,
                                    Module::AllVisible,
                                    /*IsInclusionDirective=*/false);
DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
   VisibleModules.setVisible(Mod, ImportLoc);
 
   checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
 
   // FIXME: we should support importing a submodule within a different submodule
   // of the same top-level module. Until we do, make it an error rather than
   // silently ignoring the import.
   // FIXME: Should we warn on a redundant import of the current module?
-  if (!getLangOpts().CPlusPlusModules &&
-      Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
+  if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
       (getLangOpts().isCompilingModule() || !getLangOpts().ModulesTS)) {
     Diag(ImportLoc, getLangOpts().isCompilingModule()
                         ? diag::err_module_self_import
                         : diag::err_module_import_in_implementation)
         << Mod->getFullModuleName() << getLangOpts().CurrentModule;
   }
 
   SmallVector<SourceLocation, 2> IdentifierLocs;
ImportDecl *Import = ImportDecl::Create(Context, CurContext, StartLoc,
                                           Mod, IdentifierLocs);
   CurContext->addDecl(Import);
 
   // Sequence initialization of the imported module before that of the current
   // module, if any.
   if (!ModuleScopes.empty())
     Context.addModuleInitializer(ModuleScopes.back().Module, Import);
 
-  if (!ModuleScopes.empty() && ModuleScopes.back().ModuleInterface) {
+  // A module (partition) implementation unit shall not be exported.
+  if (getLangOpts().CPlusPlusModules && Mod && ExportLoc.isValid() &&
+      Mod->Kind == Module::ModuleKind::ModulePartitionImplementation) {
+    Diag(ExportLoc, diag::err_export_partition_impl)
+    << SourceRange(ExportLoc, NamePath.back().second);
+  } else if (!ModuleScopes.empty() && ModuleScopes.back().ModuleInterface) {
     // Re-export the module if the imported module is exported.
     // Note that we don't need to add re-exported module to Imports field
     // since `Exports` implies the module is imported already.
     if (ExportLoc.isValid() || getEnclosingExportDecl(Import))
       getCurrentModule()->Exports.emplace_back(Mod, false);
     else
       getCurrentModule()->Imports.insert(Mod);
   } else if (ExportLoc.isValid()) {
     // [module.interface]p1:
     // An export-declaration shall inhabit a namespace scope and appear in the
     // purview of a module interface unit.
-    Diag(ExportLoc, diag::err_export_not_in_module_interface) << 0;
+    Diag(ExportLoc, diag::err_export_not_in_module_interface)
+         << (!ModuleScopes.empty() &&
+             !ModuleScopes.back().ImplicitGlobalModuleFragment);
   } else if (getLangOpts().isCompilingModule()) {
     Module *ThisModule = PP.getHeaderSearchInfo()
                            .lookupModule(getLangOpts().CurrentModule,
                                          ExportLoc, false, false);
     assert (ThisModule && "was expecting a module if building one");
   }
 
   return Import;

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

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=1 -x c++ %s \
+// RUN:  -o %t/M_PartImpl.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=2 -x c++ %s \
+// RUN:  -fmodule-file=%t/M_PartImpl.pcm -o %t/M.pcm -verify
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=3 -x c++ %s \
+// RUN:  -o %t/M_Part.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=4 -x c++ %s \
+// RUN:  -fmodule-file=%t/M_Part.pcm -o %t/M.pcm
+
+#if TU == 1
+module M:PartImpl;
+
+// expected-no-diagnostics
+#elif TU == 2
+export module M;
+                     // error: exported partition :Part is an implementation unit
+export import :PartImpl; // expected-error {{module partition implementations cannot be exported}}
+
+#elif TU == 3
+export module M:Part;
+
+// expected-no-diagnostics
+#elif TU == 4
+export module M;
+export import :Part;
+
+// expected-no-diagnostics
+#else
+#error "no TU set"
+#endif

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

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=0 -x c++ %s \
+// RUN:  -o %t/M.pcm
+
+// RUN: %clang_cc1 -std=c++20 -S -D TU=1 -x c++ %s \
+// RUN:  -fmodule-file=%t/M.pcm -o %t/tu_8.s -verify
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=2 -x c++ %s \
+// RUN:  -o %t/M.pcm -verify
+
+#if TU == 0
+export module M;
+
+#elif TU == 1
+module M;
+          // error: cannot import M in its own unit
+import M; // expected-error {{import of module 'M' appears within its own implementation}}
+
+#elif TU == 2
+export module M;
+          // error: cannot import M in its own unit
+import M; // expected-error {{import of module 'M' appears within its own interface}}
+
+#else
+#error "no TU set"
+#endif

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

 // RUN:  -fmodule-file=%t/B.pcm -fmodule-file=%t/C.pcm -o %t/tu_5.s -verify
 
 // RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=6 -x c++ %s \
 // RUN:  -fmodule-file=%t/B.pcm -o %t/D.pcm -verify
 
 // RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=7 -x c++ %s \
 // RUN:  -fmodule-file=%t/B.pcm -o %t/D.pcm -verify
 
-// RUN: %clang_cc1 -std=c++20 -S -D TU=8 -x c++ %s \
-// RUN:  -fmodule-file=%t/B.pcm -o %t/tu_8.s -verify
-
-// RUN: %clang_cc1 -std=c++20 -emit-module-interface -D TU=9 -x c++ %s \
-// RUN:  -o %t/B.pcm -verify
-
 // Test diagnostics for incorrect module import sequences.
 
 #if TU == 0
 
 export module B;
 
 int foo ();
 

 export module D;
 
 int delta ();
 
 module :private;
 
 import B; // expected-error {{module imports cannot be in the private module fragment}}
 
-#elif TU == 8
-
-module B;
-
-import B; // expected-error {{import of module 'B' appears within same top-level module 'B'}}
-
-#elif TU == 9
-
-export module B;
-
-import B; // expected-error {{import of module 'B' appears within same top-level module 'B'}}
-
 #else
 #error "no MODE set"
 #endif