[RFC] [C++20] [Module] Support module partitions initially

[ChuanqiXu]

Summary

This file intends to support: https://eel.is/c++draft/module.unit#3.

Module partition should be a special module interface which is imported by module units in the same module.
Note that although there is implementation module partition, it should be a module interface too since it could be imported by module units in the same module.

For a module partition primary.module.name:partition.name, the user should generate a pcm file with name primary.module.name-partition.name.pcm. Simply replace : with -. And when we try to import a partition with partition-name in primary.module.name, the compiler would try to search for primary.module.name-partition.name.pcm in the given path. The strategy to replace : with - keeps consistency with GCC.

The key problem I see in introducing module partitions is that the judgement for modules. Before, there would be only module interface unit for each module. But now, it would be many partitions which are belongs in the same module. The judgement of modules matter when the compiler want to decide whether or not a declaration is visible or reachable.

And my solution is to compare the prefix of the name before '-' to judge whether or not the two module belongs to the same module. Since '-' shouldn't show up in the original module name by the definition.
For example, 'X-A' and X-B are in the same module. But X-A and Y-A are not.

BTW, it would be problem if we want to import a module partition in another module by renaming. See clang/test/CXX/module/module.unit/p3/FromWrongModule.cpp for example.

The method looks simple and available in simple demos. I want to hear more opinions.

Test Plan: check-all

[ChuanqiXu]

Now we prefer @iains's patch.

clang/include/clang/Basic/DiagnosticParseKinds.td

 def err_global_module_introducer_not_at_start : Error<
   "'module;' introducing a global module fragment can appear only "
   "at the start of the translation unit">;
 def err_module_fragment_exported : Error<
   "%select{global|private}0 module fragment cannot be exported">;
 def err_private_module_fragment_expected_semi : Error<
   "expected ';' after private module fragment declaration">;
 def err_missing_before_module_end : Error<"expected %0 at end of module">;
-def err_unsupported_module_partition : Error<
-  "sorry, module partitions are not yet supported">;
 
 def err_export_empty : Error<"export declaration cannot be empty">;
 }
 
 let CategoryName = "Generics Issue" in {
 
 def err_objc_expected_type_parameter : Error<
   "expected type parameter name">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 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_import_in_implementation : Error<
   "@import of module '%0' in implementation of '%1'; use #import">;
+def err_module_import_in_non_module : Error <
+   "import module partition isn't allowed in non module.">;
+def err_private_module_fragment_in_module_partition : Error <
+   "private module fragment is not allowed to appear in a module partition "
+   "since a module unit with a private-module-fragment shall be the only module unit of its module.">;
 
 // 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 "
   "global module fragment">;
 def err_export_within_anonymous_namespace : Error<

clang/include/clang/Basic/Module.h

public:
   /// be this module.
   const Module *getTopLevelModule() const;
 
   /// Retrieve the name of the top-level module.
   StringRef getTopLevelModuleName() const {
     return getTopLevelModule()->Name;
   }
 
+  /// Retrieve the name which contains a C++20 module partitions.
+  StringRef getTopLevelPrimaryModuleName() const {
+    if (Kind != ModuleInterfaceUnit)
+      return getTopLevelModuleName();
+    return getTopLevelModuleName().split('-').first;
+  }
+  StringRef getPrimaryModuleName() const {
+    if (Kind != ModuleInterfaceUnit)
+      return Name;
+    return StringRef(Name).split('-').first;
+  }
+
   /// The serialized AST file for this module, if one was created.
   OptionalFileEntryRefDegradesToFileEntryPtr getASTFile() const {
     return getTopLevelModule()->ASTFile;
   }
 
   /// Set the serialized AST file for the top-level module of this module.
   void setASTFile(Optional<FileEntryRef> File) {
     assert((!File || !getASTFile() || getASTFile() == File) &&

clang/include/clang/Sema/Sema.h

private:
 
   VisibleModuleSet VisibleModules;
 
 public:
   /// Get the module owning an entity.
   Module *getOwningModule(const Decl *Entity) {
     return Entity->getOwningModule();
   }
+  StringRef getCurrentModuleName() const;
+  bool IsCurrentModulePartition() const;
 
   /// Make a merged definition of an existing hidden definition \p ND
   /// visible at the specified location.
   void makeMergedDefinitionVisible(NamedDecl *ND);
 
   bool isModuleVisible(const Module *M, bool ModulePrivate = false);
 
   // When loading a non-modular PCH files, this is used to restore module
public:
 
   /// 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;'
+    Partition,      ///< 'export module X:Y;'
+                    ///< 'module X:Y;'
   };
 
   /// The parser has processed a module-declaration that begins the definition
   /// of a module interface or implementation.
   DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
                                  SourceLocation ModuleLoc, ModuleDeclKind MDK,
-                                 ModuleIdPath Path, bool IsFirstDecl);
+                                 ModuleIdPath Path, ModuleIdPath PartitionPath,
+                                 bool IsFirstDecl);
 
   /// The parser has processed a global-module-fragment declaration that begins
   /// the definition of the global module fragment of the current module unit.
   /// \param ModuleLoc The location of the 'module' keyword.
   DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);
 
   /// The parser has processed a private-module-fragment declaration that begins
   /// the definition of the private module fragment of the current module unit.
   /// \param ModuleLoc The location of the 'module' keyword.
   /// \param PrivateLoc The location of the 'private' keyword.
   DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
                                                 SourceLocation PrivateLoc);
 
   /// The parser has processed a module import declaration.
   ///
   /// \param StartLoc The location of the first token in the declaration. This
   ///        could be the location of an '@', 'export', or 'import'.
   /// \param ExportLoc The location of the 'export' keyword, if any.
   /// \param ImportLoc The location of the 'import' keyword.
   /// \param Path The module access path.
   DeclResult ActOnModuleImport(SourceLocation StartLoc,
                                SourceLocation ExportLoc,
-                               SourceLocation ImportLoc, ModuleIdPath Path);
+                               SourceLocation ImportLoc, ModuleIdPath Path,
+                               bool IsPartition = false);
   DeclResult ActOnModuleImport(SourceLocation StartLoc,
                                SourceLocation ExportLoc,
                                SourceLocation ImportLoc, Module *M,
-                               ModuleIdPath Path = {});
+                               ModuleIdPath Path = {},
+                               bool IsPartition = false);
 
   /// The parser has processed a module import translated from a
   /// #include or similar preprocessing directive.
   void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
   void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
 
   /// The parsed has entered a submodule.
   void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);

clang/lib/Parse/Parser.cpp

if (getLangOpts().CPlusPlusModules && Tok.is(tok::colon) &&
     ExpectAndConsumeSemi(diag::err_private_module_fragment_expected_semi);
     return Actions.ActOnPrivateModuleFragmentDecl(ModuleLoc, PrivateLoc);
   }
 
   SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
   if (ParseModuleName(ModuleLoc, Path, /*IsImport*/false))
     return nullptr;
 
+  SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Partition;
   // Parse the optional module-partition.
   if (Tok.is(tok::colon)) {
-    SourceLocation ColonLoc = ConsumeToken();
-    SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Partition;
+    ConsumeToken();
     if (ParseModuleName(ModuleLoc, Partition, /*IsImport*/false))
       return nullptr;
 
-    // FIXME: Support module partition declarations.
-    Diag(ColonLoc, diag::err_unsupported_module_partition)
-      << SourceRange(ColonLoc, Partition.back().second);
-    // Recover by parsing as a non-partition.
+    MDK = Sema::ModuleDeclKind::Partition;
   }
 
   // We don't support any module attributes yet; just parse them and diagnose.
   ParsedAttributesWithRange Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
   ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr);
 
   ExpectAndConsumeSemi(diag::err_module_expected_semi);
 
-  return Actions.ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, IsFirstDecl);
+  return Actions.ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, Partition,
+                                 IsFirstDecl);
 }
 
 /// Parse a module import declaration. This is essentially the same for
 /// Objective-C and the C++ Modules TS, except for the leading '@' (in ObjC)
 /// and the trailing optional attributes (in C++).
 ///
 /// [ObjC]  @import declaration:
 ///           '@' 'import' module-name ';'
Decl *Parser::ParseModuleImport(SourceLocation AtLoc) {
   assert((AtLoc.isInvalid() ? Tok.isOneOf(tok::kw_import, tok::identifier)
                             : Tok.isObjCAtKeyword(tok::objc_import)) &&
          "Improper start to module import");
   bool IsObjCAtImport = Tok.isObjCAtKeyword(tok::objc_import);
   SourceLocation ImportLoc = ConsumeToken();
 
   SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
   Module *HeaderUnit = nullptr;
+  bool IsPartition = false;
 
   if (Tok.is(tok::header_name)) {
     // This is a header import that the preprocessor decided we should skip
     // because it was malformed in some way. Parse and ignore it; it's already
     // been diagnosed.
     ConsumeToken();
   } else if (Tok.is(tok::annot_header_unit)) {
     // This is a header import that the preprocessor mapped to a module import.
     HeaderUnit = reinterpret_cast<Module *>(Tok.getAnnotationValue());
     ConsumeAnnotationToken();
   } else if (getLangOpts().CPlusPlusModules && Tok.is(tok::colon)) {
-    SourceLocation ColonLoc = ConsumeToken();
+    ConsumeToken();
     if (ParseModuleName(ImportLoc, Path, /*IsImport*/true))
       return nullptr;
 
-    // FIXME: Support module partition import.
-    Diag(ColonLoc, diag::err_unsupported_module_partition)
-      << SourceRange(ColonLoc, Path.back().second);
-    return nullptr;
+    IsPartition = true;
   } else {
     if (ParseModuleName(ImportLoc, Path, /*IsImport*/true))
       return nullptr;
   }
 
   ParsedAttributesWithRange Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
   // We don't support any module import attributes yet.
   ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr);
 
   if (PP.hadModuleLoaderFatalFailure()) {
     // With a fatal failure in the module loader, we abort parsing.
     cutOffParsing();
     return nullptr;
   }
 
   DeclResult Import;
   if (HeaderUnit)
     Import =
         Actions.ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, HeaderUnit);
   else if (!Path.empty())
-    Import = Actions.ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Path);
+    Import = Actions.ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Path,
+                                       IsPartition);
   ExpectAndConsumeSemi(diag::err_module_expected_semi);
   if (Import.isInvalid())
     return nullptr;
 
   // Using '@import' in framework headers requires modules to be enabled so that
   // the header is parseable. Emit a warning to make the user aware.
   if (IsObjCAtImport && AtLoc.isValid()) {
     auto &SrcMgr = PP.getSourceManager();

clang/lib/Sema/SemaDecl.cpp

bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) {
   if (NewM && NewM->Kind == Module::PrivateModuleFragment)
     NewM = NewM->Parent;
   if (OldM && OldM->Kind == Module::PrivateModuleFragment)
     OldM = OldM->Parent;
 
   if (NewM == OldM)
     return false;
 
+  // If NewM and OldM are two partitions of the same module so the redeclaration
+  // should be compatible.
+  if (NewM && OldM &&
+      NewM->getPrimaryModuleName() == OldM->getPrimaryModuleName())
+    return false;
+
   bool NewIsModuleInterface = NewM && NewM->isModulePurview();
   bool OldIsModuleInterface = OldM && OldM->isModulePurview();
   if (NewIsModuleInterface || OldIsModuleInterface) {
     // C++ Modules TS [basic.def.odr] 6.2/6.7 [sic]:
     //   if a declaration of D [...] appears in the purview of a module, all
     //   other such declarations shall appear in the purview of the same module
     Diag(New->getLocation(), diag::err_mismatched_owning_module)
       << New

clang/lib/Sema/SemaLookup.cpp

if (M && !LookupModulesCache.insert(M).second)
       M = nullptr;
     CodeSynthesisContextLookupModules.push_back(M);
   }
   return LookupModulesCache;
 }
 
 /// Determine whether the module M is part of the current module from the
 /// perspective of a module-private visibility check.
-static bool isInCurrentModule(const Module *M, const LangOptions &LangOpts) {
+static bool isInCurrentModule(const Module *M, const Sema &SemaRef) {
   // If M is the global module fragment of a module that we've not yet finished
   // parsing, then it must be part of the current module.
-  return M->getTopLevelModuleName() == LangOpts.CurrentModule ||
+  return M->getTopLevelPrimaryModuleName() == SemaRef.getCurrentModuleName() ||
          (M->Kind == Module::GlobalModuleFragment && !M->Parent);
 }
 
 bool Sema::hasVisibleMergedDefinition(NamedDecl *Def) {
   for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
     if (isModuleVisible(Merged))
       return true;
   return false;
 }
 
 bool Sema::hasMergedDefinitionInCurrentModule(NamedDecl *Def) {
   for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
-    if (isInCurrentModule(Merged, getLangOpts()))
+    if (isInCurrentModule(Merged, *this))
       return true;
   return false;
 }
 
 template<typename ParmDecl>
 static bool
 hasVisibleDefaultArgument(Sema &S, const ParmDecl *D,
                           llvm::SmallVectorImpl<Module *> *Modules) {
bool LookupResult::isVisibleSlow(Sema &SemaRef, NamedDecl *D) {
   return false;
 }
 
 bool Sema::isModuleVisible(const Module *M, bool ModulePrivate) {
   // The module might be ordinarily visible. For a module-private query, that
   // means it is part of the current module. For any other query, that means it
   // is in our visible module set.
   if (ModulePrivate) {
-    if (isInCurrentModule(M, getLangOpts()))
+    if (isInCurrentModule(M, *this))
       return true;
   } else {
     if (VisibleModules.isVisible(M))
       return true;
   }
 
   // Otherwise, it might be visible by virtue of the query being within a
   // template instantiation or similar that is permitted to look inside M.

clang/lib/Sema/SemaModule.cpp

Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {
   TU->setLocalOwningModule(GlobalModule);
 
   // FIXME: Consider creating an explicit representation of this declaration.
   return nullptr;
 }
 
 Sema::DeclGroupPtrTy
 Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
-                      ModuleDeclKind MDK, ModuleIdPath Path, bool IsFirstDecl) {
+                      ModuleDeclKind MDK, ModuleIdPath Path,
+                      ModuleIdPath PartitionPath, bool IsFirstDecl) {
   assert((getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) &&
          "should only have module decl in Modules TS or C++20");
 
   // 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.
   switch (getLangOpts().getCompilingModule()) {
   case LangOptions::CMK_None:
Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
   // module name.
   std::string ModuleName;
   for (auto &Piece : Path) {
     if (!ModuleName.empty())
       ModuleName += ".";
     ModuleName += Piece.first->getName();
   }
 
+  if (MDK == ModuleDeclKind::Partition) {
+    std::string PartitionName;
+    for (auto &Piece : PartitionPath) {
+      if (!PartitionName.empty())
+        PartitionName += ".";
+      PartitionName += Piece.first->getName();
+    }
+    ModuleName += "-" + PartitionName;
+  }
+
   // 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, Path.back().second)
         << getLangOpts().CurrentModule;
     return nullptr;
   }
   const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
 
   auto &Map = PP.getHeaderSearchInfo().getModuleMap();
   Module *Mod;
 
   switch (MDK) {
+  case ModuleDeclKind::Partition:
   case ModuleDeclKind::Interface: {
     // 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);
+
     assert(Mod && "module creation should not fail");
     break;
   }
 
   case ModuleDeclKind::Implementation:
     std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
         PP.getIdentifierInfo(ModuleName), Path[0].second);
     Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},
Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
   if (!ModuleScopes.back().ModuleInterface) {
     Diag(PrivateLoc, diag::err_private_module_fragment_not_module_interface);
     Diag(ModuleScopes.back().BeginLoc,
          diag::note_not_module_interface_add_export)
         << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
     return nullptr;
   }
 
+  if (IsCurrentModulePartition()) {
+    Diag(PrivateLoc, diag::err_private_module_fragment_in_module_partition);
+    return nullptr;
+  }
+
   // FIXME: Check this isn't a module interface partition.
   // FIXME: Check that this translation unit does not import any partitions;
   // such imports would violate [basic.link]/2's "shall be the only module unit"
   // restriction.
 
   // We've finished the public fragment of the translation unit.
   ActOnEndOfTranslationUnitFragment(TUFragmentKind::Normal);
 
Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
   TU->setLocalOwningModule(PrivateModuleFragment);
 
   // FIXME: Consider creating an explicit representation of this declaration.
   return nullptr;
 }
 
 DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
                                    SourceLocation ExportLoc,
-                                   SourceLocation ImportLoc,
-                                   ModuleIdPath Path) {
+                                   SourceLocation ImportLoc, ModuleIdPath Path,
+                                   bool IsPartition) {
   // Flatten the module path for a Modules TS module name.
   std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
-  if (getLangOpts().ModulesTS) {
+  if (getLangOpts().ModulesTS || IsPartition) {
     std::string ModuleName;
     for (auto &Piece : Path) {
       if (!ModuleName.empty())
         ModuleName += ".";
       ModuleName += Piece.first->getName();
     }
+
+    if (IsPartition) {
+      assert(getLangOpts().CPlusPlusModules &&
+             "Partitions is only allowed in C++20 modules.");
+      if (getLangOpts().CurrentModule.empty())
+        Diag(ImportLoc, diag::err_module_import_in_non_module);
+      ModuleName = std::string(getCurrentModuleName()) + "-" + ModuleName;
+    }
     ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};
     Path = ModuleIdPath(ModuleNameLoc);
   }
 
   Module *Mod =
       getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
                                    /*IsInclusionDirective=*/false);
   if (!Mod)
     return true;
 
-  return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Mod, Path);
+  return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Mod, Path,
+                           IsPartition);
 }
 
 /// Determine whether \p D is lexically within an export-declaration.
 static const ExportDecl *getEnclosingExportDecl(const Decl *D) {
   for (auto *DC = D->getLexicalDeclContext(); DC; DC = DC->getLexicalParent())
     if (auto *ED = dyn_cast<ExportDecl>(DC))
       return ED;
   return nullptr;
 }
 
 DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
                                    SourceLocation ExportLoc,
-                                   SourceLocation ImportLoc,
-                                   Module *Mod, ModuleIdPath Path) {
+                                   SourceLocation ImportLoc, Module *Mod,
+                                   ModuleIdPath Path, bool IsPartition) {
   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.
   // Import-from-implementation is valid in the Modules TS. FIXME: Should we
   // warn on a redundant import of the current module?
-  // FIXME: Import of a module from an implementation partition of the same
-  // module is permitted.
-  if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
-      (getLangOpts().isCompilingModule() || !getLangOpts().ModulesTS)) {
+  if (Mod->getTopLevelPrimaryModuleName() == getCurrentModuleName() &&
+      (getLangOpts().isCompilingModule() || !getLangOpts().ModulesTS) &&
+      !IsPartition && !IsCurrentModulePartition()) {
     Diag(ImportLoc, getLangOpts().isCompilingModule()
                         ? diag::err_module_self_import
                         : diag::err_module_import_in_implementation)
-        << Mod->getFullModuleName() << getLangOpts().CurrentModule;
+        << Mod->getFullModuleName() << getCurrentModuleName();
   }
 
   SmallVector<SourceLocation, 2> IdentifierLocs;
   Module *ModCheck = Mod;
   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
     // If we've run out of module parents, just drop the remaining identifiers.
     // We need the length to be consistent.
     if (!ModCheck)
for (auto *Child : ED->decls()) {
         diagExportedUnnamedDecl(*this, UnnamedDeclKind::Context, Child,
                                 BlockStart);
       }
     }
   }
 
   return D;
 }
+
+StringRef Sema::getCurrentModuleName() const {
+  if (!getLangOpts().CPlusPlusModules)
+    return getLangOpts().CurrentModule;
+  return StringRef(getLangOpts().CurrentModule).split('-').first;
+}
+
+bool Sema::IsCurrentModulePartition() const {
+  return StringRef(getLangOpts().CurrentModule).contains('-');
+}

clang/lib/Sema/SemaType.cpp

if (!Incomplete) {
     if (Def &&
         !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) {
       // If the user is going to see an error here, recover by making the
       // definition visible.
       bool TreatAsComplete = Diagnoser && !isSFINAEContext();
       if (Diagnoser && SuggestedDef)
         diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition,
                               /*Recover*/TreatAsComplete);
+      // FIXME: It is possible to emit duplicated diagnostic message. See
+      // CXX/module/module.reach/p4/X.cpp for example.
       return !TreatAsComplete;
     } else if (Def && !TemplateInstCallbacks.empty()) {
       CodeSynthesisContext TempInst;
       TempInst.Kind = CodeSynthesisContext::Memoization;
       TempInst.Template = Def;
       TempInst.Entity = Def;
       TempInst.PointOfInstantiation = Loc;
       atTemplateBegin(TemplateInstCallbacks, *this, TempInst);

clang/test/CXX/module/module.global.frag/Inputs/X-A.cppm

+module;
+#include "header.h"
+export module X:A;

clang/test/CXX/module/module.global.frag/Inputs/header.h

+constexpr int n = 1;

clang/test/CXX/module/module.global.frag/p2.cpp

+// This test tests that the declaration in the global module fragment 
+// couldn't be used in other module unit even they are in the same module.
+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/Inputs/X-A.cppm -emit-module-interface -o %t/X-A.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+
+export module X:B;
+import :A;
+export int foo() {
+    return n; // expected-error {{'n' must be declared before it is used}}
+              // expected-note@Inputs/header.h:1 {{declaration here is not visible}}
+}

clang/test/CXX/module/module.import/Inputs/M-Part.cppm

+module M:Part;

clang/test/CXX/module/module.import/p8.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/Inputs/M-Part.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/M-Part.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+// expected-no-diagnostics
+// FIXME: We couldn't export module M:Part since it is an implementation module.
+
+export module M;
+export import :Part;    // error: exported partition :Part is an implementation unit

clang/test/CXX/module/module.private.frag/p1.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+
+export module X:A;
+export struct S;
+module :private; // expected-error {{private module fragment is not allowed to appear in a module partition}}
+struct S{};

clang/test/CXX/module/module.reach/Inputs/p4/M-A.cppm

+export module M:A;
+export struct B;

clang/test/CXX/module/module.reach/Inputs/p4/M-B.cppm

+module M:B;
+struct B {
+  operator int();
+};

clang/test/CXX/module/module.reach/Inputs/p4/M.cppm

+export module M;
+export import :A;
+import :B;
+B b2;
+export void f(B b = B());

clang/test/CXX/module/module.reach/p4/M-C.cppm

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/M-A.cppm -emit-module-interface -o %t/M-A.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+
+module M:C;
+import :A;                      // Since the compiler couldn't see the defintion of 'B' too, it couldn't
+                                // give better diagnostic message.
+B b1;                           // expected-error {{variable has incomplete type 'B'}}
+                                // expected-note@../Inputs/p4/M-A.cppm:2 {{forward declaration of 'B'}}

clang/test/CXX/module/module.reach/p4/X.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/M-A.cppm -emit-module-interface -o %t/M-A.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/M-B.cppm -emit-module-interface -o %t/M-B.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/M.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/M.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+
+export module X;
+import M;
+                                // FIXME: Eliminate the duplicated diagnostics.
+B b3;                           // expected-error {{definition of 'B' must be imported}}
+                                // expected-error@-1 {{definition of 'B' must be imported}}
+                                // expected-note@../Inputs/p4/M-B.cppm:2 {{definition here is not reachable}}
+                                // expected-note@../Inputs/p4/M-B.cppm:2 {{definition here is not reachable}}
+void g() { f(); }               // FIXME: The default argument of f() shouldn't be reachable from here. 

clang/test/CXX/module/module.unit/Inputs/p3/X.cppm

+export module X;
+export import :parta;
+import :partb;
+export int use() {
+    return a() + b();
+}

clang/test/CXX/module/module.unit/Inputs/p3/parta.cppm

+export module X:parta;
+
+export int a() {
+    return 1;
+}

clang/test/CXX/module/module.unit/Inputs/p3/partb.cppm

+module X:partb;
+import :parta;
+int b() {
+    return 2 + a();
+}

clang/test/CXX/module/module.unit/Inputs/p4/A-Foo.cppm

+export module A:Foo;
+import :Internals;
+export int foo() { return 2 * (bar() + 1); }

clang/test/CXX/module/module.unit/Inputs/p4/A-Impl.cpp

+// expected-no-diagnostics
+module A;
+import :Internals;
+int bar() { return baz() - 10; }
+int baz() { return 30; }

clang/test/CXX/module/module.unit/Inputs/p4/A-Internals.cppm

+module A:Internals;
+int bar();

clang/test/CXX/module/module.unit/Inputs/p4/A.cppm

+export module A;
+export import :Foo;
+export int baz();

clang/test/CXX/module/module.unit/Inputs/p8/B-X1.cppm

+module B:X1;                    // does not implicitly import B
+int &a = n;                     // expected-error {{use of undeclared identifier 'n'}}

clang/test/CXX/module/module.unit/Inputs/p8/B-X2.cppm

+// expected-no-diagnostics
+module B:X2;                    // does not implicitly import B
+import B;
+int &b = n;                     // OK

clang/test/CXX/module/module.unit/Inputs/p8/B-Y.cppm

+module B:Y;                     // does not implicitly import B
+int y();
+#ifdef TESTING
+int _ = n;                      // expected-error {{use of undeclared identifier}}
+#endif

clang/test/CXX/module/module.unit/Inputs/p8/B.cppm

+export module B;
+import :Y;                      // OK, does not create interface dependency cycle
+int n = y();

clang/test/CXX/module/module.unit/p3.cpp

-// RUN: %clang_cc1 -std=c++2a -verify %s
-
-export module foo:bar; // expected-error {{sorry, module partitions are not yet supported}}
-import :baz; // expected-error {{sorry, module partitions are not yet supported}}

clang/test/CXX/module/module.unit/p3/FromNonModule.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p3/parta.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/X-parta.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+
+import :parta; // expected-error {{import module partition isn't allowed in non module.}}
+               // expected-error@-1 {{not found}}
+
+int use() {
+    return a();
+}

clang/test/CXX/module/module.unit/p3/FromWrongModule.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p3/parta.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/Y-parta.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+
+export module Y;
+import :parta;  // expected-error {{error in loading module 'Y-parta' from prebuilt module path}}
+
+int use() {
+    return a();
+}

clang/test/CXX/module/module.unit/p3/simple.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+// expected-no-diagnostics
+
+export module foo:bar;

clang/test/CXX/module/module.unit/p3/user.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p3/parta.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/X-parta.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p3/partb.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/X-partb.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p3/X.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/X.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+// expected-no-diagnostics
+
+import X;
+
+int user() {
+    return use();
+}

clang/test/CXX/module/module.unit/p4/user.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/A-Internals.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/A-Internals.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/A-Foo.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/A-Foo.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/A.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/A.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p4/A-Impl.cpp -fmodule-file=%t/A.pcm -fprebuilt-module-path=%t -verify
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %s
+
+import A;
+
+int user() {
+    return foo()+baz();
+}
+
+int user2() {
+    return foo() + baz() + bar(); // expected-error {{use of undeclared identifier 'bar'}}
+                                  // expected-note@*{{declared here}}
+                                  // NOTE: The note above notes the possible compiling error, which is irrevelant with module
+}

clang/test/CXX/module/module.unit/p8/B-Impl.cppm

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p8/B-Y.cppm -fprebuilt-module-path=%t -DTESTING -verify
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p8/B-Y.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/B-Y.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p8/B.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/B.pcm
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p8/B-X1.cppm -fprebuilt-module-path=%t -verify
+// RUN: %clang_cc1 -std=c++20 %S/../Inputs/p8/B-X2.cppm -fprebuilt-module-path=%t -verify
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -fmodule-file=%t/B.pcm -verify %s
+// expected-no-diagnostics
+
+module B;                       // implicitly imports B
+int &c = n;                     // OK

clang/test/CXX/module/module.unit/p8/ImplicitImport.cpp

 export module foo; // expected-error {{redefinition of module 'foo'}}
 // expected-note-re@* {{module loaded from '{{.*}}.pcm'}}
 #define IMPORTED
 
 #elif MODE == 3
 export module bar;
 
 #elif MODE == 4
-module foo:bar; // expected-error {{not yet supported}}
-#define IMPORTED // FIXME
+module foo:bar;
 
 #elif MODE == 5
-export module foo:bar; // expected-error {{not yet supported}} expected-error {{redefinition}} expected-note@* {{loaded from}}
-#define IMPORTED // FIXME
+export module foo:bar; 
 
 #endif
 
 int k = n;
 #ifndef IMPORTED
 // expected-error@-2 {{declaration of 'n' must be imported from module 'foo' before it is required}}
 // expected-note@* {{not visible}}
 #endif