[clang][cas] Correctly split out modules that are only imported for visibility

Modules imported for visibility only can happen when -fmodule-name
matches a modular header that is imported more than once so that we
trigger the correct re-exports but without trying to import a module.

(cherry picked from commit d844c16)
(cherry picked from commit 02b64b7)

Author: benlangmuir

clang/include/clang/Basic/DiagnosticLexKinds.td

@@ -918,6 +918,9 @@ def warn_defined_in_function_type_macro : Extension<
   "macro expansion producing 'defined' has undefined behavior">,
   InGroup<ExpansionToDefined>;
 
+def err_pp_missing_module_include_tree : Error<
+  "no module named '%0' declared in include-tree module map">, DefaultFatal;
+
 let CategoryName = "Nullability Issue" in {
 
 def err_pp_assume_nonnull_syntax : Error<"expected 'begin' or 'end'">;

clang/include/clang/CAS/IncludeTree.h

@@ -331,17 +331,20 @@ class IncludeTree::ModuleImport : public IncludeTreeBase<ModuleImport> {
 public:
   static constexpr StringRef getNodeKind() { return "ModI"; }
 
-  static Expected<ModuleImport> create(ObjectStore &DB, StringRef ModuleName);
+  static Expected<ModuleImport> create(ObjectStore &DB, StringRef ModuleName,
+                                       bool VisibilityOnly);
 
-  StringRef getModuleName() { return getData(); }
+  StringRef getModuleName() const { return getData().drop_front(); }
+  /// Whether this module should only be "marked visible" rather than imported.
+  bool visibilityOnly() const { return (bool)getData()[0]; }
 
   llvm::Error print(llvm::raw_ostream &OS, unsigned Indent = 0);
 
   static bool isValid(const ObjectProxy &Node) {
     if (!IncludeTreeBase::isValid(Node))
       return false;
     IncludeTreeBase Base(Node);
-    return Base.getNumReferences() == 0 && !Base.getData().empty();
+    return Base.getNumReferences() == 0 && Base.getData().size() > 1;
   }
   static bool isValid(ObjectStore &DB, ObjectRef Ref) {
     auto Node = DB.getProxy(Ref);

clang/include/clang/Lex/PPCachedActions.h

@@ -39,6 +39,8 @@ class PPCachedActions {
   /// The module that is imported by an \c #include directive or \c @import.
   struct IncludeModule {
     SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> ImportPath;
+    // Whether this module should only be "marked visible" rather than imported.
+    bool VisibilityOnly;
   };
 
   virtual ~PPCachedActions() = default;

clang/lib/CAS/IncludeTree.cpp

@@ -212,9 +212,12 @@ bool IncludeTree::isValid(const ObjectProxy &Node) {
 }
 
 Expected<IncludeTree::ModuleImport>
-IncludeTree::ModuleImport::create(ObjectStore &DB, StringRef ModuleName) {
-  return IncludeTreeBase::create(DB, {},
-                                 llvm::arrayRefFromStringRef<char>(ModuleName));
+IncludeTree::ModuleImport::create(ObjectStore &DB, StringRef ModuleName,
+                                  bool VisibilityOnly) {
+  SmallString<64> Buffer;
+  Buffer.push_back((char)VisibilityOnly);
+  Buffer.append(ModuleName);
+  return IncludeTreeBase::create(DB, {}, Buffer);
 }
 
 IncludeTree::FileList::FileSizeTy
@@ -600,7 +603,11 @@ llvm::Error IncludeTree::FileList::print(llvm::raw_ostream &OS,
 
 llvm::Error IncludeTree::ModuleImport::print(llvm::raw_ostream &OS,
                                              unsigned Indent) {
-  OS << "(Module) " << getModuleName() << '\n';
+  if (visibilityOnly())
+    OS << "(Module for visibility only) ";
+  else
+    OS << "(Module) ";
+  OS << getModuleName() << '\n';
   return llvm::Error::success();
 }
 

clang/lib/Frontend/IncludeTreePPActions.cpp

@@ -123,7 +123,7 @@ class IncludeTreePPActions final : public PPCachedActions {
       Import.getModuleName().split(ModuleComponents, '.');
       for (StringRef Component : ModuleComponents)
         Path.emplace_back(PP.getIdentifierInfo(Component), IncludeLoc);
-      return IncludeModule{std::move(Path)};
+      return IncludeModule{std::move(Path), Import.visibilityOnly()};
     }
 
     assert(Node->getKind() == cas::IncludeTree::NodeKind::Tree);

clang/lib/Lex/PPDirectives.cpp

@@ -2011,17 +2011,36 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
       return;
     }
     if (auto *Import = std::get_if<PPCachedActions::IncludeModule>(&Include)) {
-      ModuleLoadResult Imported = TheModuleLoader.loadModule(
-          IncludeTok.getLocation(), Import->ImportPath, Module::Hidden,
-          /*IsIncludeDirective=*/true);
-      if (!Imported) {
-        assert(hadModuleLoaderFatalFailure() && "unexpected failure kind");
-        if (hadModuleLoaderFatalFailure()) {
-          IncludeTok.setKind(tok::eof);
-          CurLexer->cutOffLexing();
+      ModuleLoadResult Imported;
+      if (Import->VisibilityOnly) {
+        ModuleMap &MMap = getHeaderSearchInfo().getModuleMap();
+        Module *M = nullptr;
+        for (auto &NameLoc : Import->ImportPath) {
+          M = MMap.lookupModuleQualified(NameLoc.first->getName(), M);
+          if (!M)
+            break;
+        }
+        if (!M) {
+          Diags->Report(diag::err_pp_missing_module_include_tree)
+              << getLangOpts().CurrentModule;
+
+          return;
+        }
+        Imported = M;
+      } else {
+        Imported = TheModuleLoader.loadModule(
+            IncludeTok.getLocation(), Import->ImportPath, Module::Hidden,
+            /*IsIncludeDirective=*/true);
+        if (!Imported) {
+          assert(hadModuleLoaderFatalFailure() && "unexpected failure kind");
+          if (hadModuleLoaderFatalFailure()) {
+            IncludeTok.setKind(tok::eof);
+            CurLexer->cutOffLexing();
+          }
+          return;
         }
-        return;
       }
+
       makeModuleVisible(Imported, EndLoc);
       if (IncludeTok.getIdentifierInfo()->getPPKeywordID() !=
           tok::pp___include_macros)

clang/lib/Tooling/DependencyScanning/DependencyScanningWorker.cpp

@@ -458,6 +458,10 @@ class DependencyScanningAction : public tooling::ToolAction {
     else
       Action = std::make_unique<ReadPCHAndPreprocessAction>();
 
+    // Normally this would be handled by GeneratePCHAction
+    if (ScanInstance.getFrontendOpts().ProgramAction == frontend::GeneratePCH)
+      ScanInstance.getLangOpts().CompilingPCH = true;
+
     if (Error E = Controller.initialize(ScanInstance, OriginalInvocation))
       return reportError(std::move(E));
 

clang/lib/Tooling/DependencyScanning/IncludeTreeActionController.cpp

@@ -397,8 +397,9 @@ void IncludeTreeBuilder::handleHasIncludeCheck(Preprocessor &PP, bool Result) {
 
 void IncludeTreeBuilder::moduleImport(Preprocessor &PP, const Module *M,
                                       SourceLocation EndLoc) {
-  auto Import =
-      check(cas::IncludeTree::ModuleImport::create(DB, M->getFullModuleName()));
+  bool VisibilityOnly = M->isForBuilding(PP.getLangOpts());
+  auto Import = check(cas::IncludeTree::ModuleImport::create(
+      DB, M->getFullModuleName(), VisibilityOnly));
   if (!Import)
     return;
 

clang/test/ClangScanDeps/modules-include-tree-implementation-private.c

@@ -23,6 +23,8 @@
 // CHECK:   Submodule: Mod
 // CHECK: 3:1 [[PREFIX]]/Mod.framework/PrivateHeaders/Priv.h  llvmcas://
 // CHECK:   Submodule: Mod_Private
+// CHECK: 4:1 (Module for visibility only) Mod
+// CHECK: 5:1 (Module for visibility only) Mod_Private
 // CHECK: Module Map:
 // CHECK: Mod (framework)
 // CHECK:   link Mod (framework)
@@ -59,6 +61,8 @@ void priv(void);
 //--- tu.m
 #import <Mod/Mod.h>
 #import <Mod/Priv.h>
+#import <Mod/Mod.h>
+#import <Mod/Priv.h>
 void tu(void) {
   pub();
   priv();

clang/test/ClangScanDeps/modules-include-tree-implementation.c

@@ -27,7 +27,7 @@
 
 // CHECK: 2:1 [[PREFIX]]/Mod.h llvmcas://{{[[:xdigit:]]+}}
 // CHECK:   Submodule: Mod
-// CHECK: 3:1 (Module) Mod
+// CHECK: 3:1 (Module for visibility only) Mod
 
 // CHECK: Files:
 // CHECK: [[PREFIX]]/tu.c llvmcas://{{[[:xdigit:]]+}}