[C++20][Modules][8/8] Amend module visibility rules for partitions.

[iains]

Summary

Implementation partitions bring two extra cases where we have
visibility of module-private data.

1. When we import a module implementation partition.
2. When a partition implementation imports the primary module intertace.

We maintain a record of direct imports into the current module since
partition decls from direct imports (but not trasitive ones) are visible.

The rules on decl-reachability are much more relaxed (with the standard
giving permission for an implementation to load dependent modules and for
the decls there to be reachable, but not visible).

[iains]

rebased onto import state machine

[iains]

Rebased onto other modules work.

[iains]

update formatting.

[iains]

re-push format changes

[iains]

patch 8 of 8 implementing basic C++20 module partition support.

[iains]

rebased onto changes in parent patches.

[ChuanqiXu]

LGTM.

[iains]

rebase onto parent patch changes.

[iains]

rebased

[iains]

rebased

[h-vetinari]

A non-actionable comment out of curiosity for the work

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

15–17

Should these two tests now be switched on? Missing a RUN: for that IIUC?

[iains]

rebased, fix missing RUN lines for two cases in a test.

[iains]

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

15–17

good catch, thanks!

clang/lib/Sema/SemaLookup.cpp

 /// your module can see, including those later on in your module).
 bool LookupResult::isVisibleSlow(Sema &SemaRef, NamedDecl *D) {
   assert(!D->isUnconditionallyVisible() &&
          "should not call this: not in slow case");
 
   Module *DeclModule = SemaRef.getOwningModule(D);
   assert(DeclModule && "hidden decl has no owning module");
 
-  // If the owning module is visible, the decl is visible.
   if (SemaRef.isModuleVisible(DeclModule, D->isModulePrivate()))
+    // If the owning module is visible, the decl is visible.
     return true;
 
   // Determine whether a decl context is a file context for the purpose of
   // visibility. This looks through some (export and linkage spec) transparent
   // contexts, but not others (enums).
   auto IsEffectivelyFileContext = [](const DeclContext *DC) {
     return DC->isFileContext() || isa<LinkageSpecDecl>(DC) ||
            isa<ExportDecl>(DC);

 
 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()))
       return true;
+    else if (M->Kind == Module::ModuleKind::ModulePartitionImplementation &&
+             isModuleDirectlyImported(M))
+      // Unless a partition implementation is directly imported it is not
+      // counted as visible for lookup, although the contained decls might
+      // still be reachable.  It's a partition, so it must be part of the
+      // current module to be a valid import.
+      return true;
+    else if (getLangOpts().CPlusPlusModules && !ModuleScopes.empty() &&
+             ModuleScopes[0].Module->Kind ==
+                 Module::ModuleKind::ModulePartitionImplementation &&
+             ModuleScopes[0].Module->getPrimaryModuleInterfaceName() ==
+                 M->Name &&
+             isModuleDirectlyImported(M))
+      // We are building a module implementation partition and the TU imports
+      // the primary module interface unit.
+      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/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