[clang][modules] Apply local submodule visibility to includes

[jansvoboda11]

Summary

With this patch, the preprocessor tracks the set of included files on per-submodule basis with -fmodules-local-submodule-visibility.

Depends on D155503.

[jansvoboda11]

Rebase

[jansvoboda11]

Rebase on top of D155503.

clang/include/clang/Lex/Preprocessor.h

 //===- Preprocessor.h - C Language Family Preprocessor ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
private:
   };
   SmallVector<BuildingSubmoduleInfo, 8> BuildingSubmoduleStack;
 
   /// Information about a submodule's preprocessor state.
   struct SubmoduleState {
     /// The macros for the submodule.
     MacroMap Macros;
 
+    /// The set of files that have been included in the submodule.
+    IncludedFilesSet IncludedFiles;
+
     /// The set of modules that are visible within the submodule.
     VisibleModuleSet VisibleModules;
 
     // FIXME: CounterValue?
     // FIXME: PragmaPushMacroInfo?
   };
   std::map<Module *, SubmoduleState> Submodules;
 
   /// The preprocessor state for preprocessing outside of any submodule.
   SubmoduleState NullSubmoduleState;
 
   /// The current submodule state. Will be \p NullSubmoduleState if we're not
   /// in a submodule.
   SubmoduleState *CurSubmoduleState;
 
   /// The set of files that have been included in each submodule.
   /// Files included outside of any module (e.g. in PCH) have nullptr key.
   llvm::DenseMap<Module *, IncludedFilesSet> IncludedFilesPerSubmodule;
 
-  /// The files that have been included.
-  IncludedFilesSet IncludedFiles;
-
   /// The set of top-level modules that affected preprocessing, but were not
   /// imported.
   llvm::SmallSetVector<Module *, 2> AffectingClangModules;
 
   /// The set of known macros exported from modules.
   llvm::FoldingSet<ModuleMacro> ModuleMacros;
 
   /// The names of potential module macros that we've not yet processed.
const llvm::SmallSetVector<Module *, 2> &getAffectingClangModules() const {
     return AffectingClangModules;
   }
 
   /// Mark the file as included in the current state.
   /// Do not attribute it to the current module - this file was included by one
   /// of its dependencies (transitively).
   void markTransitivelyIncluded(const FileEntry *File) {
     HeaderInfo.getFileInfo(File);
-    IncludedFiles.insert(File);
+    CurSubmoduleState->IncludedFiles.insert(File);
   }
 
   /// Mark the file as included in the current state and attribute it to the
   /// current module.
   /// Returns true if this is the first time the file was included.
   bool markDirectlyIncluded(const FileEntry *File) {
     HeaderInfo.getFileInfo(File);
 
     Module *M = !BuildingSubmoduleStack.empty()
                     ? BuildingSubmoduleStack.back().M
                     : getCurrentModule();
     IncludedFilesPerSubmodule[M].insert(File);
 
-    return IncludedFiles.insert(File).second;
+    return CurSubmoduleState->IncludedFiles.insert(File).second;
   }
 
   /// Return true if this header has already been included.
   bool alreadyIncluded(const FileEntry *File) const {
     HeaderInfo.getFileInfo(File);
-    return IncludedFiles.count(File);
+    return CurSubmoduleState->IncludedFiles.count(File);
   }
 
   /// Invoke the callback for every module known to include the given file.
   void forModulesIncluding(const FileEntry *FE,
                            llvm::function_ref<void(Module *)> Cb) {
     // TODO: Maintain a data-structure that provides this more efficiently.
     for (const auto &Entry : IncludedFilesPerSubmodule)
       if (Entry.second.contains(FE))
         Cb(Entry.first);
   }
 
   /// Get the set of files included in the given module.
   IncludedFilesSet &getFilesIncludedIn(Module *M) {
     return IncludedFilesPerSubmodule[M];
   }
 
-  /// Get the set of included files.
-  IncludedFilesSet &getIncludedFiles() { return IncludedFiles; }
-  const IncludedFilesSet &getIncludedFiles() const { return IncludedFiles; }
+  /// Get the set of files included in the current state.
+  IncludedFilesSet &getIncludedFiles() {
+    return CurSubmoduleState->IncludedFiles;
+  }
 
   /// Return the name of the macro defined before \p Loc that has
   /// spelling \p Tokens.  If there are multiple macros with same spelling,
   /// return the last one defined.
   StringRef getLastMacroWithSpelling(SourceLocation Loc,
                                      ArrayRef<TokenValue> Tokens) const;
 
   /// Get the predefines for this processor.

clang/test/Modules/import-textual-noguard.mm

 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -fmodules -fimplicit-module-maps -I%S/Inputs/import-textual/M2 -fmodules-cache-path=%t -x objective-c++ -fmodules-local-submodule-visibility %s -verify
 
-#include "A/A.h" // expected-error {{could not build module 'M'}}
+// expected-no-diagnostics
+
+#include "A/A.h"
 #include "B/B.h"
 
 typedef aint xxx;
 typedef bint yyy;