[Modules] Allow modules specified by -fmodule-map-file to shadow implicitly found ones

[bruno]

Summary

When modules come from module map files explicitly specified by
-fmodule-map-file= arguments, allow those to override/shadow modules
with the same name that are found implicitly by header search. If such a
module is looked up by name (e.g. @import), we will always find the one
from -fmodule-map-file. If we try to use a shadowed module by including
one of its headers report an error.

This enables developers to force use of a specific copy of their module
to be used if there are multiple copies that would otherwise be visible,
for example if they develop modules that are installed in the default
search paths.

We're using this internally for a couple years now, it would be nice to have it upstreamed.

Patch originally by Ben Langmuir,
http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20151116/143425.html

Based on cfe-dev discussion:
http://lists.llvm.org/pipermail/cfe-dev/2015-November/046164.html

[bruno]

Ping!

[bruno]

Ping!

[rsmith]

This makes a lot of sense to me. See also r302463: I think we probably want three levels of shadowing here: the main input shadows -fmodule-map-file, which shadows module maps loaded implicitly. (There's also a question of what we do with module map information loaded from an AST file: currently when that happens, we ignore the tokens for the parsed module map entirely. It might make more sense to have the module loaded from the AST file shadow the module from the module map, especially for an explicit module build, now that we have that functionality.)

lib/Lex/ModuleMap.cpp

2574–2575 ↗

(On Diff #92738)

It would seem cleaner to make this a member of ModuleMapParser (and explicitly pass down the flag when parsing an extern module declaration). Is there a reason to use (essentially) global state for this?

[bruno]

It might make more sense to have the module loaded from the AST file shadow the module from the module map, especially for an explicit module build, now that we have that functionality.)

+1, seems a much more consistent model.

lib/Lex/ModuleMap.cpp

2574–2575 ↗

(On Diff #92738)

I don't believe there's any reason for using a global state here (and Ben doesn't recall any specific reason either). I changed the patch to pass down the flag and it works fine.

cfe/trunk/include/clang/Basic/DiagnosticCommonKinds.td

 def err_module_unavailable : Error<
   "module '%0' %select{is incompatible with|requires}1 feature '%2'">;
 def err_module_header_missing : Error<
   "%select{|umbrella }0header '%1' not found">;
 def remark_module_lock_failure : Remark<
   "could not acquire lock file for module '%0': %1">, InGroup<ModuleBuild>;
 def remark_module_lock_timeout : Remark<
   "timed out waiting to acquire lock file for module '%0'">, InGroup<ModuleBuild>;
+def err_module_shadowed : Error<"import of shadowed module '%0'">, DefaultFatal;
+def err_module_build_shadowed_submodule : Error<
+  "build a shadowed submodule '%0'">, DefaultFatal;
 def err_module_cycle : Error<"cyclic dependency in module '%0': %1">, 
   DefaultFatal;
 def err_module_prebuilt : Error<
   "error in loading module '%0' from prebuilt module path">, DefaultFatal;
 def note_pragma_entered_here : Note<"#pragma entered here">;  
 def note_decl_hiding_tag_type : Note<
   "%1 %0 is hidden by a non-type declaration of %0 here">;
 def err_attribute_not_type_attr : Error<

cfe/trunk/include/clang/Basic/Module.h

public:
   using Requirement = std::pair<std::string, bool>;
 
   /// \brief The set of language features required to use this module.
   ///
   /// If any of these requirements are not available, the \c IsAvailable bit
   /// will be false to indicate that this (sub)module is not available.
   SmallVector<Requirement, 2> Requirements;
 
+  /// \brief A module with the same name that shadows this module.
+  Module *ShadowingModule = nullptr;
+
   /// \brief Whether this module is missing a feature from \c Requirements.
   unsigned IsMissingRequirement : 1;
 
   /// \brief Whether we tried and failed to load a module file for this module.
   unsigned HasIncompatibleModuleFile : 1;
 
   /// \brief Whether this module is available in the current translation unit.
   ///
public:
   /// \brief Determine whether this module is available for use within the
   /// current translation unit.
   ///
   /// \param LangOpts The language options used for the current
   /// translation unit.
   ///
   /// \param Target The target options used for the current translation unit.
   ///
-  /// \param Req If this module is unavailable, this parameter
-  /// will be set to one of the requirements that is not met for use of
-  /// this module.
+  /// \param Req If this module is unavailable because of a missing requirement,
+  /// this parameter will be set to one of the requirements that is not met for
+  /// use of this module.
+  ///
+  /// \param MissingHeader If this module is unavailable because of a missing
+  /// header, this parameter will be set to one of the missing headers.
+  ///
+  /// \param ShadowingModule If this module is unavailable because it is
+  /// shadowed, this parameter will be set to the shadowing module.
   bool isAvailable(const LangOptions &LangOpts, 
                    const TargetInfo &Target,
                    Requirement &Req,
-                   UnresolvedHeaderDirective &MissingHeader) const;
+                   UnresolvedHeaderDirective &MissingHeader,
+                   Module *&ShadowingModule) const;
 
   /// \brief Determine whether this module is a submodule.
   bool isSubModule() const { return Parent != nullptr; }
   
   /// \brief Determine whether this module is a submodule of the given other
   /// module.
   bool isSubModuleOf(const Module *Other) const;
   

cfe/trunk/include/clang/Lex/HeaderSearch.h

enum LoadModuleMapResult {
     /// \brief There was either no module map file or the module map file was
     /// invalid.
     LMM_InvalidModuleMap
   };
 
   LoadModuleMapResult loadModuleMapFileImpl(const FileEntry *File,
                                             bool IsSystem,
                                             const DirectoryEntry *Dir,
+                                            bool IsExplicitlyProvided,
                                             FileID ID = FileID(),
                                             unsigned *Offset = nullptr);
 
   /// \brief Try to load the module map file in the given directory.
   ///
   /// \param DirName The name of the directory where we will look for a module
   /// map file.
   /// \param IsSystem Whether this is a system header directory.

cfe/trunk/include/clang/Lex/ModuleMap.h

private:
   /// \brief Mapping from directories with umbrella headers to the module
   /// that is generated from the umbrella header.
   ///
   /// This mapping is used to map headers that haven't explicitly been named
   /// in the module map over to the module that includes them via its umbrella
   /// header.
   llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
 
+  /// \brief The set of modules provided explicitly (e.g. by -fmodule-map-file),
+  /// which are allowed to shadow other implicitly discovered modules.
+  llvm::DenseSet<const Module *> ExplicitlyProvidedModules;
+
+  bool mayShadowModuleBeingParsed(Module *ExistingModule,
+                                  bool IsExplicitlyProvided) {
+    assert(!ExistingModule->Parent && "expected top-level module");
+    return !IsExplicitlyProvided &&
+           ExplicitlyProvidedModules.count(ExistingModule);
+  }
+
   /// \brief The set of attributes that can be attached to a module.
   struct Attributes {
     /// \brief Whether this is a system module.
     unsigned IsSystem : 1;
 
     /// \brief Whether this is an extern "C" module.
     unsigned IsExternC : 1;
 
public:
   /// or nullptr to indicate that this is a top-level module.
   ///
   /// \param IsFramework Whether this is a framework module.
   ///
   /// \param IsExplicit Whether this is an explicit submodule.
   ///
   /// \returns The found or newly-created module, along with a boolean value
   /// that will be true if the module is newly-created.
-  std::pair<Module *, bool> findOrCreateModule(StringRef Name, Module *Parent,
-                                               bool IsFramework,
-                                               bool IsExplicit);
+  std::pair<Module *, bool>
+  findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework,
+                     bool IsExplicit, bool UsesExplicitModuleMapFile = false);
 
   /// \brief Create a 'global module' for a C++ Modules TS module interface
   /// unit.
   ///
   /// We model the global module as a submodule of the module interface unit.
   /// Unfortunately, we can't create the module interface unit's Module until
   /// later, because we don't know what it will be called.
   Module *createGlobalModuleForInterfaceUnit(SourceLocation Loc);
 
   /// \brief Create a new module for a C++ Modules TS module interface unit.
   /// The module must not already exist, and will be configured for the current
   /// compilation.
   ///
   /// Note that this also sets the current module to the newly-created module.
   ///
   /// \returns The newly-created module.
   Module *createModuleForInterfaceUnit(SourceLocation Loc, StringRef Name,
                                        Module *GlobalModule);
 
   /// \brief Infer the contents of a framework module map from the given
   /// framework directory.
   Module *inferFrameworkModule(const DirectoryEntry *FrameworkDir,
                                bool IsSystem, Module *Parent);
 
+  /// \brief Create a new top-level module that is shadowed by
+  /// \p ShadowingModule.
+  Module *createShadowedModule(StringRef Name, bool IsFramework,
+                               Module *ShadowingModule);
+
   /// \brief Retrieve the module map file containing the definition of the given
   /// module.
   ///
   /// \param Module The module whose module map file will be returned, if known.
   ///
   /// \returns The file entry for the module map file containing the given
   /// module, or nullptr if the module definition was inferred.
   const FileEntry *getContainingModuleMapFile(const Module *Module) const;
public:
   /// \brief Adds this header to the given module.
   /// \param Role The role of the header wrt the module.
   void addHeader(Module *Mod, Module::Header Header,
                  ModuleHeaderRole Role, bool Imported = false);
 
   /// \brief Marks this header as being excluded from the given module.
   void excludeHeader(Module *Mod, Module::Header Header);
 
+  void setExplicitlyProvided(Module *Mod);
+
   /// \brief Parse the given module map file, and record any modules we 
   /// encounter.
   ///
   /// \param File The file to be parsed.
   ///
   /// \param IsSystem Whether this module map file is in a system header
   /// directory, and therefore should be considered a system module.
   ///
   /// \param HomeDir The directory in which relative paths within this module
   ///        map file will be resolved.
   ///
   /// \param ID The FileID of the file to process, if we've already entered it.
   ///
   /// \param Offset [inout] On input the offset at which to start parsing. On
   ///        output, the offset at which the module map terminated.
   ///
   /// \param ExternModuleLoc The location of the "extern module" declaration
   ///        that caused us to load this module map file, if any.
   ///
+  /// \param IsExplicitlyProvided Whether this module map file was provided
+  /// explicitly by the user (e.g. -fmodule-map-file), rather than found
+  /// implicitly.
+  ///
   /// \returns true if an error occurred, false otherwise.
   bool parseModuleMapFile(const FileEntry *File, bool IsSystem,
-                          const DirectoryEntry *HomeDir, FileID ID = FileID(),
-                          unsigned *Offset = nullptr,
+                          const DirectoryEntry *HomeDir,
+                          bool IsExplicitlyProvided = false,
+                          FileID ID = FileID(), unsigned *Offset = nullptr,
                           SourceLocation ExternModuleLoc = SourceLocation());
 
   /// \brief Dump the contents of the module map, for debugging purposes.
   void dump();
   
   using module_iterator = llvm::StringMap<Module *>::const_iterator;
 
   module_iterator module_begin() const { return Modules.begin(); }
   module_iterator module_end()   const { return Modules.end(); }
 };
   
 } // namespace clang
 
 #endif // LLVM_CLANG_LEX_MODULEMAP_H

cfe/trunk/lib/Basic/Module.cpp

if (!HasFeature)
     HasFeature = std::find(LangOpts.ModuleFeatures.begin(),
                            LangOpts.ModuleFeatures.end(),
                            Feature) != LangOpts.ModuleFeatures.end();
   return HasFeature;
 }
 
 bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
                          Requirement &Req,
-                         UnresolvedHeaderDirective &MissingHeader) const {
+                         UnresolvedHeaderDirective &MissingHeader,
+                         Module *&ShadowingModule) const {
   if (IsAvailable)
     return true;
 
   for (const Module *Current = this; Current; Current = Current->Parent) {
+    if (Current->ShadowingModule) {
+      ShadowingModule = Current->ShadowingModule;
+      return false;
+    }
     for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
       if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
               Current->Requirements[I].second) {
         Req = Current->Requirements[I];
         return false;
       }
     }
     if (!Current->MissingHeaders.empty()) {

cfe/trunk/lib/Lex/HeaderSearch.cpp

if (llvm::sys::path::filename(DirName) == "Modules") {
       if (DirName.endswith(".framework"))
         Dir = FileMgr.getDirectory(DirName);
       // FIXME: This assert can fail if there's a race between the above check
       // and the removal of the directory.
       assert(Dir && "parent must exist");
     }
   }
 
-  switch (loadModuleMapFileImpl(File, IsSystem, Dir, ID, Offset)) {
+  switch (loadModuleMapFileImpl(File, IsSystem, Dir,
+                                /*IsExplictlyProvided=*/true, ID, Offset)) {
   case LMM_AlreadyLoaded:
   case LMM_NewlyLoaded:
     return false;
   case LMM_NoDirectory:
   case LMM_InvalidModuleMap:
     return true;
   }
   llvm_unreachable("Unknown load module map result");
 }
 
-HeaderSearch::LoadModuleMapResult
-HeaderSearch::loadModuleMapFileImpl(const FileEntry *File, bool IsSystem,
-                                    const DirectoryEntry *Dir, FileID ID,
-                                    unsigned *Offset) {
+HeaderSearch::LoadModuleMapResult HeaderSearch::loadModuleMapFileImpl(
+    const FileEntry *File, bool IsSystem, const DirectoryEntry *Dir,
+    bool IsExplicitlyProvided, FileID ID, unsigned *Offset) {
   assert(File && "expected FileEntry");
 
   // Check whether we've already loaded this module map, and mark it as being
   // loaded in case we recursively try to load it from itself.
   auto AddResult = LoadedModuleMaps.insert(std::make_pair(File, true));
   if (!AddResult.second)
     return AddResult.first->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
 
-  if (ModMap.parseModuleMapFile(File, IsSystem, Dir, ID, Offset)) {
+  if (ModMap.parseModuleMapFile(File, IsSystem, Dir, IsExplicitlyProvided, ID,
+                                Offset)) {
     LoadedModuleMaps[File] = false;
     return LMM_InvalidModuleMap;
   }
 
   // Try to load a corresponding private module map.
   if (const FileEntry *PMMFile = getPrivateModuleMap(File, FileMgr)) {
-    if (ModMap.parseModuleMapFile(PMMFile, IsSystem, Dir)) {
+    if (ModMap.parseModuleMapFile(PMMFile, IsSystem, Dir,
+                                  IsExplicitlyProvided)) {
       LoadedModuleMaps[File] = false;
       return LMM_InvalidModuleMap;
     }
   }
 
   // This directory has a module map.
   return LMM_NewlyLoaded;
 }

 HeaderSearch::LoadModuleMapResult 
 HeaderSearch::loadModuleMapFile(const DirectoryEntry *Dir, bool IsSystem,
                                 bool IsFramework) {
   auto KnownDir = DirectoryHasModuleMap.find(Dir);
   if (KnownDir != DirectoryHasModuleMap.end())
     return KnownDir->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
 
   if (const FileEntry *ModuleMapFile = lookupModuleMapFile(Dir, IsFramework)) {
-    LoadModuleMapResult Result =
-        loadModuleMapFileImpl(ModuleMapFile, IsSystem, Dir);
+    LoadModuleMapResult Result = loadModuleMapFileImpl(
+        ModuleMapFile, IsSystem, Dir, /*IsExplicitlyProvided=*/false);
     // Add Dir explicitly in case ModuleMapFile is in a subdirectory.
     // E.g. Foo.framework/Modules/module.modulemap
     //      ^Dir                  ^ModuleMapFile
     if (Result == LMM_NewlyLoaded)
       DirectoryHasModuleMap[Dir] = true;
     else if (Result == LMM_InvalidModuleMap)
       DirectoryHasModuleMap[Dir] = false;
     return Result;

cfe/trunk/lib/Lex/ModuleMap.cpp

 
 Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) const{
   if (!Context)
     return findModule(Name);
   
   return Context->findSubmodule(Name);
 }
 
-std::pair<Module *, bool> ModuleMap::findOrCreateModule(StringRef Name,
-                                                        Module *Parent,
-                                                        bool IsFramework,
-                                                        bool IsExplicit) {
+std::pair<Module *, bool>
+ModuleMap::findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework,
+                              bool IsExplicit, bool UsesExplicitModuleMapFile) {
   // Try to find an existing module with this name.
   if (Module *Sub = lookupModuleQualified(Name, Parent))
     return std::make_pair(Sub, false);
-  
   // Create a new module with this name.
   Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
                               IsExplicit, NumCreatedModules++);
   if (!Parent) {
     if (LangOpts.CurrentModule == Name)
       SourceModule = Result;
     Modules[Name] = Result;
+    if (UsesExplicitModuleMapFile)
+      ExplicitlyProvidedModules.insert(Result);
   }
   return std::make_pair(Result, true);
 }
 
 Module *ModuleMap::createGlobalModuleForInterfaceUnit(SourceLocation Loc) {
   assert(!PendingGlobalModule && "created multiple global modules");
   PendingGlobalModule.reset(
       new Module("<global>", Loc, nullptr, /*IsFramework*/ false,
Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
   // framework.
   if (!Result->isSubFramework()) {
     inferFrameworkLink(Result, FrameworkDir, FileMgr);
   }
 
   return Result;
 }
 
+Module *ModuleMap::createShadowedModule(StringRef Name, bool IsFramework,
+                                        Module *ShadowingModule) {
+
+  // Create a new module with this name.
+  Module *Result =
+      new Module(Name, SourceLocation(), /*Parent=*/nullptr, IsFramework,
+                 /*IsExplicit=*/false, NumCreatedModules++);
+  Result->ShadowingModule = ShadowingModule;
+  Result->IsAvailable = false;
+
+  return Result;
+}
+
 void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader,
                                   Twine NameAsWritten) {
   Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader));
   Mod->Umbrella = UmbrellaHeader;
   Mod->UmbrellaAsWritten = NameAsWritten.str();
   UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
 
   // Notify callbacks that we just added a new header.
void ModuleMap::excludeHeader(Module *Mod, Module::Header Header) {
   // umbrella directory module.
   // FIXME: Should we only exclude it from umbrella modules within the
   // specified module?
   (void) Headers[Header.Entry];
 
   Mod->Headers[Module::HK_Excluded].push_back(std::move(Header));
 }
 
+void ModuleMap::setExplicitlyProvided(Module *Mod) {
+  assert(Modules[Mod->Name] == Mod && "explicitly provided module is shadowed");
+  ExplicitlyProvidedModules.insert(Mod);
+}
+
 const FileEntry *
 ModuleMap::getContainingModuleMapFile(const Module *Module) const {
   if (Module->DefinitionLoc.isInvalid())
     return nullptr;
 
   return SourceMgr.getFileEntryForID(
            SourceMgr.getFileID(Module->DefinitionLoc));
 }
class ModuleMapParser {
     /// contents of the Darwin.C.excluded (assert.h) and Tcl.Private modules as
     /// non-modular headers.  For backwards compatibility, we continue to
     /// support this idiom for just these modules, and map the headers to
     /// 'textual' to match the original intent.
     llvm::SmallPtrSet<Module *, 2> UsesRequiresExcludedHack;
 
     /// \brief Consume the current token and return its location.
     SourceLocation consumeToken();
-    
+    bool UsesExplicitModuleMapFile = false;
+
     /// \brief Skip tokens until we reach the a token with the given kind
     /// (or the end of the file).
     void skipUntil(MMToken::TokenKind K);
 
     using ModuleId = SmallVector<std::pair<std::string, SourceLocation>, 2>;
 
     bool parseModuleId(ModuleId &Id);
     void parseModuleDecl();
class ModuleMapParser {
     void parseConflict();
     void parseInferredModuleDecl(bool Framework, bool Explicit);
 
     using Attributes = ModuleMap::Attributes;
 
     bool parseOptionalAttributes(Attributes &Attrs);
     
   public:
-    explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr, 
-                             const TargetInfo *Target,
-                             DiagnosticsEngine &Diags,
-                             ModuleMap &Map,
-                             const FileEntry *ModuleMapFile,
-                             const DirectoryEntry *Directory,
-                             bool IsSystem)
+    explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
+                             const TargetInfo *Target, DiagnosticsEngine &Diags,
+                             ModuleMap &Map, const FileEntry *ModuleMapFile,
+                             const DirectoryEntry *Directory, bool IsSystem,
+                             bool UsesExplicitModuleMapFile)
         : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map),
           ModuleMapFile(ModuleMapFile), Directory(Directory),
-          IsSystem(IsSystem) {
+          IsSystem(IsSystem),
+          UsesExplicitModuleMapFile(UsesExplicitModuleMapFile) {
       Tok.clear();
       consumeToken();
     }
-    
     bool parseModuleMapFile();
 
     bool terminatedByDirective() { return false; }
     SourceLocation getLocation() { return Tok.getLocation(); }
   };
 
 } // namespace clang
 
if (!Tok.is(MMToken::LBrace)) {
     Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace)
       << ModuleName;
     HadError = true;
     return;
   }  
   SourceLocation LBraceLoc = consumeToken();
   
   // Determine whether this (sub)module has already been defined.
+  Module *ShadowingModule = nullptr;
   if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) {
     // We might see a (re)definition of a module that we already have a
     // definition for in two cases:
     //  - If we loaded one definition from an AST file and we've just found a
     //    corresponding definition in a module map file, or
     bool LoadedFromASTFile = Existing->DefinitionLoc.isInvalid();
     //  - If we're building a (preprocessed) module and we've just loaded the
     //    module map file from which it was created.
if (!ActiveModule && (LoadedFromASTFile || ParsedAsMainInput)) {
         consumeToken();
       else {
         Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
         Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
         HadError = true;        
       }
       return;
     }
-    
+    if (!Existing->Parent &&
+        Map.mayShadowModuleBeingParsed(Existing, UsesExplicitModuleMapFile)) {
+      ShadowingModule = Existing;
+    } else {
+      // This is not a shawdowed module decl, it is an illegal redefinition.
       Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition)
           << ModuleName;
       Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition);
-    
       // Skip the module definition.
       skipUntil(MMToken::RBrace);
       if (Tok.is(MMToken::RBrace))
         consumeToken();
-    
       HadError = true;
       return;
     }
+  }
 
   // Start defining this module.
+  if (ShadowingModule) {
+    ActiveModule =
+        Map.createShadowedModule(ModuleName, Framework, ShadowingModule);
+  } else {
     ActiveModule = Map.findOrCreateModule(ModuleName, ActiveModule, Framework,
-                                        Explicit).first;
+                                          Explicit, UsesExplicitModuleMapFile)
+                       .first;
+  }
+
   ActiveModule->DefinitionLoc = ModuleNameLoc;
   if (Attrs.IsSystem || IsSystem)
     ActiveModule->IsSystem = true;
   if (Attrs.IsExternC)
     ActiveModule->IsExternC = true;
   if (Attrs.NoUndeclaredIncludes ||
       (!ActiveModule->Parent && ModuleName == "Darwin"))
     ActiveModule->NoUndeclaredIncludes = true;
if (llvm::sys::path::is_relative(FileNameRef)) {
     FileNameRef = ModuleMapFileName;
   }
   if (const FileEntry *File = SourceMgr.getFileManager().getFile(FileNameRef))
     Map.parseModuleMapFile(
         File, /*IsSystem=*/false,
         Map.HeaderInfo.getHeaderSearchOpts().ModuleMapFileHomeIsCwd
             ? Directory
             : File->getDir(),
-        FileID(), nullptr, ExternLoc);
+        false /*IsExplicitlyProvided*/, FileID(), nullptr, ExternLoc);
 }
 
 /// Whether to add the requirement \p Feature to the module \p M.
 ///
 /// This preserves backwards compatibility for two hacks in the Darwin system
 /// module map files:
 ///
 /// 1. The use of 'requires excluded' to make headers non-modular, which
case MMToken::UseKeyword:
       HadError = true;
       consumeToken();
       break;
     }
   } while (true);
 }
 
 bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
-                                   const DirectoryEntry *Dir, FileID ID,
+                                   const DirectoryEntry *Dir,
+                                   bool IsExplicitlyProvided, FileID ID,
                                    unsigned *Offset,
                                    SourceLocation ExternModuleLoc) {
   assert(Target && "Missing target information");
   llvm::DenseMap<const FileEntry *, bool>::iterator Known
     = ParsedModuleMap.find(File);
   if (Known != ParsedModuleMap.end())
     return Known->second;
 
bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
 
   // Parse this module map file.
   Lexer L(SourceMgr.getLocForStartOfFile(ID), MMapLangOpts,
           Buffer->getBufferStart(),
           Buffer->getBufferStart() + (Offset ? *Offset : 0),
           Buffer->getBufferEnd());
   SourceLocation Start = L.getSourceLocation();
   ModuleMapParser Parser(L, SourceMgr, Target, Diags, *this, File, Dir,
-                         IsSystem);
+                         IsSystem, IsExplicitlyProvided);
   bool Result = Parser.parseModuleMapFile();
   ParsedModuleMap[File] = Result;
 
   if (Offset) {
     auto Loc = SourceMgr.getDecomposedLoc(Parser.getLocation());
     assert(Loc.first == ID && "stopped in a different file?");
     *Offset = Loc.second;
   }
 
   // Notify callbacks that we parsed it.
   for (const auto &Cb : Callbacks)
     Cb->moduleMapFileRead(Start, *File, IsSystem);
+
   return Result;
 }

cfe/trunk/lib/Lex/PPDirectives.cpp

static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
   return SuggestReplacement;
 }
 
 bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts,
                                           const TargetInfo &TargetInfo,
                                           DiagnosticsEngine &Diags, Module *M) {
   Module::Requirement Requirement;
   Module::UnresolvedHeaderDirective MissingHeader;
-  if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader))
+  Module *ShadowingModule = nullptr;
+  if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader,
+                     ShadowingModule))
     return false;
 
   if (MissingHeader.FileNameLoc.isValid()) {
     Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
         << MissingHeader.IsUmbrella << MissingHeader.FileName;
+  } else if (ShadowingModule) {
+    Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name;
+    Diags.Report(ShadowingModule->DefinitionLoc,
+                 diag::note_previous_definition);
   } else {
     // FIXME: Track the location at which the requirement was specified, and
     // use it here.
     Diags.Report(M->DefinitionLoc, diag::err_module_unavailable)
         << M->getFullModuleName() << Requirement.second << Requirement.first;
   }
   return true;
 }
#endif
   assert(FID.isValid() && "Expected valid file ID");
 
   // If all is good, enter the new file!
   if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation()))
     return;
 
   // Determine if we're switching to building a new submodule, and which one.
   if (auto *M = SuggestedModule.getModule()) {
+    if (M->getTopLevelModule()->ShadowingModule) {
+      // We are building a submodule that belongs to a shadowed module. This
+      // means we find header files in the shadowed module.
+      Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule)
+        << M->getFullModuleName();
+      Diag(M->getTopLevelModule()->ShadowingModule->DefinitionLoc,
+           diag::note_previous_definition);
+      return;
+    }
     // When building a pch, -fmodule-name tells the compiler to textually
     // include headers in the specified module. We are not building the
     // specified module.
     if (getLangOpts().CompilingPCH &&
         M->getTopLevelModuleName() == getLangOpts().CurrentModule)
       return;
 
     assert(!CurLexerSubmodule && "should not have marked this as a module yet");

cfe/trunk/test/Modules/Inputs/shadow/A1/A.h

+#define A1_A_h

cfe/trunk/test/Modules/Inputs/shadow/A1/module.modulemap

+module A {
+  header "A.h"
+}
+
+module A1 {}

cfe/trunk/test/Modules/Inputs/shadow/A2/A.h

+#define A2_A_h

cfe/trunk/test/Modules/Inputs/shadow/A2/module.modulemap

+module A {
+  header "A.h"
+}
+
+module A2 {}

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A1/Foo.h

+#include <stdarg.h> // expected-error {{could not build module 'A'}}

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A1/module.modulemap

+module A [system] { // expected-note {{previous definition is here}}
+  module sub {
+    header "sys/A.h"
+  }
+  module sub2 {
+    header "sys/A2.h"
+  }
+  module stdarg {
+    header "stdarg.h"
+    export *
+  }
+}
+
+module A2 {}

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A1/sys/A.h

+#include <sys/A2.h>

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A1/sys/A2.h

+// nothing

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A2/Foo.h

+#include <stdarg.h>

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A2/module.modulemap

+module A [system] {
+  module sub {
+    header "sys/A.h"
+  }
+  module sub2 { // expected-error {{build a shadowed submodule 'A.sub2'}}
+    header "sys/A2.h"
+  }
+  module stdarg {
+    header "stdarg.h"
+    export *
+  }
+}
+
+module A2 {}

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A2/sys/A.h

+#include <sys/A2.h>

cfe/trunk/test/Modules/Inputs/shadowed-submodule/A2/sys/A2.h

+// nothing

cfe/trunk/test/Modules/Inputs/shadowed-submodule/Foo/module.modulemap

+module Foo {
+  header "../A1/Foo.h"
+}

cfe/trunk/test/Modules/shadow.m

+// RUN: rm -rf %t
+// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/shadow/A1 -I %S/Inputs/shadow/A2 %s -fsyntax-only 2>&1 | FileCheck %s -check-prefix=REDEFINITION
+// RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodule-map-file=%S/Inputs/shadow/A1/module.modulemap -fmodule-map-file=%S/Inputs/shadow/A2/module.modulemap %s -fsyntax-only 2>&1 | FileCheck %s -check-prefix=REDEFINITION
+// REDEFINITION: error: redefinition of module 'A'
+// REDEFINITION: note: previously defined
+
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -fmodule-map-file=%S/Inputs/shadow/A1/module.modulemap -I %S/Inputs/shadow %s -verify
+
+@import A1;
+@import A2;
+@import A;
+
+#import "A2/A.h" // expected-note {{implicitly imported}}
+// expected-error@A2/module.modulemap:1 {{import of shadowed module 'A'}}
+// expected-note@A1/module.modulemap:1 {{previous definition}}
+
+#if defined(A2_A_h)
+#error got the wrong definition of module A
+#elif !defined(A1_A_h)
+#error missing definition from A1
+#endif

cfe/trunk/test/Modules/shadowed-submodule.m

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/shadowed-submodule/Foo -I %S/Inputs/shadowed-submodule/A2 %s -verify
+
+@import Foo; // expected-error {{module 'A' was built in directory}}
+             // expected-note@shadowed-submodule.m:4 {{imported by module 'Foo'}}