CbC/CbC_llvm: clang/lib/Lex/HeaderSearch.cpp comparison

comparison clang/lib/Lex/HeaderSearch.cpp @ 252:1f2b6ac9f198 llvm-original

LLVM16-1

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Fri, 18 Aug 2023 09:04:13 +0900
parents	c4bab56944e8
children

comparison

equal deleted inserted replaced

-:c80f45b162ad
+:1f2b6ac9f198
 for (auto &HM : HeaderMaps)
 Names.push_back(std::string(HM.first->getName()));
 }
 std::string HeaderSearch::getCachedModuleFileName(Module *Module) {
-Optional<FileEntryRef> ModuleMap =
+OptionalFileEntryRef ModuleMap =
 getModuleMap().getModuleMapFileForUniquing(Module);
 // The ModuleMap maybe a nullptr, when we load a cached C++ module without
 // *.modulemap file. In this case, just return an empty string.
 if (!ModuleMap)
 return {};
 return {};
 }
 std::string HeaderSearch::getPrebuiltImplicitModuleFileName(Module *Module) {
-Optional<FileEntryRef> ModuleMap =
+OptionalFileEntryRef ModuleMap =
 getModuleMap().getModuleMapFileForUniquing(Module);
 StringRef ModuleName = Module->Name;
 StringRef ModuleMapPath = ModuleMap->getName();
 StringRef ModuleCacheHash = HSOpts->DisableModuleHash ? "" : getModuleHash();
 for (const std::string &Dir : HSOpts->PrebuiltModulePaths) {
 if (Dir.isFramework()) {
 // Search for or infer a module map for a framework. Here we use
 // SearchName rather than ModuleName, to permit finding private modules
 // named FooPrivate in buggy frameworks named Foo.
 SmallString<128> FrameworkDirName;
-FrameworkDirName += Dir.getFrameworkDir()->getName();
+FrameworkDirName += Dir.getFrameworkDirRef()->getName();
 llvm::sys::path::append(FrameworkDirName, SearchName + ".framework");
 if (auto FrameworkDir =
 FileMgr.getOptionalDirectoryRef(FrameworkDirName)) {
 bool IsSystem = Dir.getDirCharacteristic() != SrcMgr::C_User;
 Module = loadFrameworkModule(ModuleName, *FrameworkDir, IsSystem);
 // Only deal with normal search directories.
 if (!Dir.isNormalDir())
 continue;
 bool IsSystem = Dir.isSystemHeaderDirectory();
-// Only returns None if not a normal directory, which we just checked
+// Only returns std::nullopt if not a normal directory, which we just
+// checked
 DirectoryEntryRef NormalDir = *Dir.getDirRef();
 // Search for a module map file in this directory.
 if (loadModuleMapFile(NormalDir, IsSystem,
 /*IsFramework*/false) == LMM_NewlyLoaded) {
 // We just loaded a module map file; check whether the module is
 }
 // Search for a module map in a subdirectory with the same name as the
 // module.
 SmallString<128> NestedModuleMapDirName;
-NestedModuleMapDirName = Dir.getDir()->getName();
+NestedModuleMapDirName = Dir.getDirRef()->getName();
 llvm::sys::path::append(NestedModuleMapDirName, ModuleName);
 if (loadModuleMapFile(NestedModuleMapDirName, IsSystem,
 /*IsFramework*/false) == LMM_NewlyLoaded){
 // If we just loaded a module map file, look for the module again.
 Module = ModMap.findModule(ModuleName);
 void HeaderSearch::indexInitialHeaderMaps() {
 llvm::StringMap<unsigned, llvm::BumpPtrAllocator> Index(SearchDirs.size());
 // Iterate over all filename keys and associate them with the index i.
-unsigned i = 0;
+for (unsigned i = 0; i != SearchDirs.size(); ++i) {
-for (; i != SearchDirs.size(); ++i) {
 auto &Dir = SearchDirs[i];
 // We're concerned with only the initial contiguous run of header
 // maps within SearchDirs, which can be 99% of SearchDirs when
 // SearchDirs.size() is ~10000.
-if (!Dir.isHeaderMap())
+if (!Dir.isHeaderMap()) {
+SearchDirHeaderMapIndex = std::move(Index);
+FirstNonHeaderMapSearchDirIdx = i;
 break;
+}
 // Give earlier keys precedence over identical later keys.
 auto Callback = [&](StringRef Filename) {
 Index.try_emplace(Filename.lower(), i);
 };
 Dir.getHeaderMap()->forEachKey(Callback);
 }
-SearchDirHeaderMapIndex = std::move(Index);
-FirstNonHeaderMapSearchDirIdx = i;
 }
 //===----------------------------------------------------------------------===//
 // File lookup within a DirectoryLookup scope
 //===----------------------------------------------------------------------===//
 /// getName - Return the directory or filename corresponding to this lookup
 /// object.
 StringRef DirectoryLookup::getName() const {
-// FIXME: Use the name from \c DirectoryEntryRef.
 if (isNormalDir())
-return getDir()->getName();
+return getDirRef()->getName();
 if (isFramework())
-return getFrameworkDir()->getName();
+return getFrameworkDirRef()->getName();
 assert(isHeaderMap() && "Unknown DirectoryLookup");
 return getHeaderMap()->getFileName();
 }
-Optional<FileEntryRef> HeaderSearch::getFileAndSuggestModule(
+OptionalFileEntryRef HeaderSearch::getFileAndSuggestModule(
 StringRef FileName, SourceLocation IncludeLoc, const DirectoryEntry *Dir,
 bool IsSystemHeaderDir, Module *RequestingModule,
 ModuleMap::KnownHeader *SuggestedModule, bool OpenFile /*=true*/,
 bool CacheFailures /*=true*/) {
 // If we have a module map that might map this header, load it and
 EC != llvm::errc::invalid_argument &&
 EC != llvm::errc::is_a_directory && EC != llvm::errc::not_a_directory) {
 Diags.Report(IncludeLoc, diag::err_cannot_open_file)
 << FileName << EC.message();
 }
-return None;
+return std::nullopt;
 }
 // If there is a module that corresponds to this header, suggest it.
 if (!findUsableModuleForHeader(
-&File->getFileEntry(), Dir ? Dir : File->getFileEntry().getDir(),
+*File, Dir ? Dir : File->getFileEntry().getDir(), RequestingModule,
-RequestingModule, SuggestedModule, IsSystemHeaderDir))
+SuggestedModule, IsSystemHeaderDir))
-return None;
+return std::nullopt;
 return *File;
 }
 /// LookupFile - Lookup the specified file in this search path, returning it
 /// if it exists or returning null if not.
-Optional<FileEntryRef> DirectoryLookup::LookupFile(
+OptionalFileEntryRef DirectoryLookup::LookupFile(
 StringRef &Filename, HeaderSearch &HS, SourceLocation IncludeLoc,
 SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
 Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule,
 bool &InUserSpecifiedSystemFramework, bool &IsFrameworkFound,
 bool &IsInHeaderMap, SmallVectorImpl<char> &MappedName,
 assert(isHeaderMap() && "Unknown directory lookup");
 const HeaderMap *HM = getHeaderMap();
 SmallString<1024> Path;
 StringRef Dest = HM->lookupFilename(Filename, Path);
 if (Dest.empty())
-return None;
+return std::nullopt;
 IsInHeaderMap = true;
-auto FixupSearchPath = [&]() {
+auto FixupSearchPathAndFindUsableModule =
+[&](FileEntryRef File) -> OptionalFileEntryRef {
 if (SearchPath) {
 StringRef SearchPathRef(getName());
 SearchPath->clear();
 SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
 }
 if (RelativePath) {
 RelativePath->clear();
 RelativePath->append(Filename.begin(), Filename.end());
 }
+if (!HS.findUsableModuleForHeader(File, File.getFileEntry().getDir(),
+RequestingModule, SuggestedModule,
+isSystemHeaderDirectory())) {
+return std::nullopt;
+}
+return File;
 };
 // Check if the headermap maps the filename to a framework include
 // ("Foo.h" -> "Foo/Foo.h"), in which case continue header lookup using the
 // framework include.
 Filename = StringRef(MappedName.begin(), MappedName.size());
 Dest = HM->lookupFilename(Filename, Path);
 }
 if (auto Res = HS.getFileMgr().getOptionalFileRef(Dest, OpenFile)) {
-FixupSearchPath();
+return FixupSearchPathAndFindUsableModule(*Res);
-return *Res;
 }
 // Header maps need to be marked as used whenever the filename matches.
 // The case where the target file **exists** is handled by callee of this
 // function as part of the regular logic that applies to include search paths.
 // The case where the target file **does not exist** is handled here:
 HS.noteLookupUsage(HS.searchDirIdx(*this), IncludeLoc);
-return None;
+return std::nullopt;
 }
 /// Given a framework directory, find the top-most framework directory.
 ///
 /// \param FileMgr The file manager to use for directory lookups.
 /// \param DirName The name of the framework directory.
 /// \param SubmodulePath Will be populated with the submodule path from the
 /// returned top-level module to the originally named framework.
-static Optional<DirectoryEntryRef>
+static OptionalDirectoryEntryRef
 getTopFrameworkDir(FileManager &FileMgr, StringRef DirName,
 SmallVectorImpl<std::string> &SubmodulePath) {
 assert(llvm::sys::path::extension(DirName) == ".framework" &&
 "Not a framework directory");
 (RequestingModule && RequestingModule->NoUndeclaredIncludes);
 }
 /// DoFrameworkLookup - Do a lookup of the specified file in the current
 /// DirectoryLookup, which is a framework directory.
-Optional<FileEntryRef> DirectoryLookup::DoFrameworkLookup(
+OptionalFileEntryRef DirectoryLookup::DoFrameworkLookup(
 StringRef Filename, HeaderSearch &HS, SmallVectorImpl<char> *SearchPath,
 SmallVectorImpl<char> *RelativePath, Module *RequestingModule,
 ModuleMap::KnownHeader *SuggestedModule,
 bool &InUserSpecifiedSystemFramework, bool &IsFrameworkFound) const {
 FileManager &FileMgr = HS.getFileMgr();
 // Framework names must have a '/' in the filename.
 size_t SlashPos = Filename.find('/');
 if (SlashPos == StringRef::npos)
-return None;
+return std::nullopt;
 // Find out if this is the home for the specified framework, by checking
 // HeaderSearch.  Possible answers are yes/no and unknown.
 FrameworkCacheEntry &CacheEntry =
 HS.LookupFrameworkCache(Filename.substr(0, SlashPos));
 // If it is known and in some other directory, fail.
 if (CacheEntry.Directory && CacheEntry.Directory != getFrameworkDirRef())
-return None;
+return std::nullopt;
 // Otherwise, construct the path to this framework dir.
 // FrameworkName = "/System/Library/Frameworks/"
 SmallString<1024> FrameworkName;
 ++NumFrameworkLookups;
 // If the framework dir doesn't exist, we fail.
 auto Dir = FileMgr.getDirectory(FrameworkName);
 if (!Dir)
-return None;
+return std::nullopt;
 // Otherwise, if it does, remember that this is the right direntry for this
 // framework.
 CacheEntry.Directory = getFrameworkDirRef();
 }
 // If we found the header and are allowed to suggest a module, do so now.
 if (File && needModuleLookup(RequestingModule, SuggestedModule)) {
 // Find the framework in which this header occurs.
-StringRef FrameworkPath = File->getFileEntry().getDir()->getName();
+StringRef FrameworkPath = File->getDir().getName();
 bool FoundFramework = false;
 do {
 // Determine whether this directory exists.
 auto Dir = FileMgr.getDirectory(FrameworkPath);
 if (!Dir)
 break;
 } while (true);
 bool IsSystem = getDirCharacteristic() != SrcMgr::C_User;
 if (FoundFramework) {
-if (!HS.findUsableModuleForFrameworkHeader(
+if (!HS.findUsableModuleForFrameworkHeader(*File, FrameworkPath,
-&File->getFileEntry(), FrameworkPath, RequestingModule,
+RequestingModule,
 SuggestedModule, IsSystem))
-return None;
+return std::nullopt;
 } else {
-if (!HS.findUsableModuleForHeader(&File->getFileEntry(), getDir(),
+if (!HS.findUsableModuleForHeader(*File, getDir(), RequestingModule,
-RequestingModule, SuggestedModule,
+SuggestedModule, IsSystem))
-IsSystem))
+return std::nullopt;
-return None;
 }
 }
 if (File)
 return *File;
-return None;
+return std::nullopt;
 }
 void HeaderSearch::cacheLookupSuccess(LookupFileCacheInfo &CacheLookup,
 ConstSearchDirIterator HitIt,
 SourceLocation Loc) {
 /// LookupFile - Given a "foo" or \<foo> reference, look up the indicated file,
 /// return null on failure.  isAngled indicates whether the file reference is
 /// for system \#include's or not (i.e. using <> instead of ""). Includers, if
 /// non-empty, indicates where the \#including file(s) are, in case a relative
 /// search is needed. Microsoft mode will pass all \#including files.
-Optional<FileEntryRef> HeaderSearch::LookupFile(
+OptionalFileEntryRef HeaderSearch::LookupFile(
 StringRef Filename, SourceLocation IncludeLoc, bool isAngled,
 ConstSearchDirIterator FromDir, ConstSearchDirIterator *CurDirArg,
-ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>> Includers,
+ArrayRef<std::pair<const FileEntry *, DirectoryEntryRef>> Includers,
 SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
 Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule,
 bool *IsMapped, bool *IsFrameworkFound, bool SkipCache,
 bool BuildSystemModule, bool OpenFile, bool CacheFailures) {
 ConstSearchDirIterator CurDirLocal = nullptr;
 if (llvm::sys::path::is_absolute(Filename)) {
 CurDir = nullptr;
 // If this was an #include_next "/absolute/file", fail.
 if (FromDir)
-return None;
+return std::nullopt;
 if (SearchPath)
 SearchPath->clear();
 if (RelativePath) {
 RelativePath->clear();
 CacheFailures);
 }
 // This is the header that MSVC's header search would have found.
 ModuleMap::KnownHeader MSSuggestedModule;
-Optional<FileEntryRef> MSFE;
+OptionalFileEntryRef MSFE;
 // Unless disabled, check to see if the file is in the #includer's
 // directory.  This cannot be based on CurDir, because each includer could be
 // a #include of a subdirectory (#include "foo/bar.h") and a subsequent
 // include of "baz.h" should resolve to "whatever/foo/baz.h".
 for (const auto &IncluderAndDir : Includers) {
 const FileEntry *Includer = IncluderAndDir.first;
 // Concatenate the requested file onto the directory.
 // FIXME: Portability.  Filename concatenation should be in sys::Path.
-TmpDir = IncluderAndDir.second->getName();
+TmpDir = IncluderAndDir.second.getName();
 TmpDir.push_back('/');
 TmpDir.append(Filename.begin(), Filename.end());
 // FIXME: We don't cache the result of getFileInfo across the call to
 // getFileAndSuggestModule, because it's a reference to an element of
 // from a module build. We should treat this as a system header if we're
 // building a [system] module.
 bool IncluderIsSystemHeader =
 Includer ? getFileInfo(Includer).DirInfo != SrcMgr::C_User :
 BuildSystemModule;
-if (Optional<FileEntryRef> FE = getFileAndSuggestModule(
+if (OptionalFileEntryRef FE = getFileAndSuggestModule(
 TmpDir, IncludeLoc, IncluderAndDir.second, IncluderIsSystemHeader,
 RequestingModule, SuggestedModule)) {
 if (!Includer) {
 assert(First && "only first includer can have no file");
 return FE;
 ToHFI.DirInfo = DirInfo;
 ToHFI.IndexHeaderMapHeader = IndexHeaderMapHeader;
 ToHFI.Framework = Framework;
 if (SearchPath) {
-StringRef SearchPathRef(IncluderAndDir.second->getName());
+StringRef SearchPathRef(IncluderAndDir.second.getName());
 SearchPath->clear();
 SearchPath->append(SearchPathRef.begin(), SearchPathRef.end());
 }
 if (RelativePath) {
 RelativePath->clear();
 RelativePath->append(Filename.begin(), Filename.end());
 }
 if (First) {
 diagnoseFrameworkInclude(Diags, IncludeLoc,
-IncluderAndDir.second->getName(), Filename,
+IncluderAndDir.second.getName(), Filename,
 &FE->getFileEntry());
 return FE;
 }
 // Otherwise, we found the path via MSVC header search rules.  If
 LookupFileCacheInfo &CacheLookup = LookupFileCache[Filename];
 ConstSearchDirIterator NextIt = std::next(It);
 if (!SkipCache) {
-if (CacheLookup.StartIt == NextIt) {
+if (CacheLookup.StartIt == NextIt &&
+CacheLookup.RequestingModule == RequestingModule) {
 // HIT: Skip querying potentially lots of directories for this lookup.
 if (CacheLookup.HitIt)
 It = CacheLookup.HitIt;
 if (CacheLookup.MappedName) {
 Filename = CacheLookup.MappedName;
 }
 } else {
 // MISS: This is the first query, or the previous query didn't match
 // our search start.  We will fill in our found location below, so prime
 // the start point value.
-CacheLookup.reset(/*NewStartIt=*/NextIt);
+CacheLookup.reset(RequestingModule, /*NewStartIt=*/NextIt);
 if (It == search_dir_begin() && FirstNonHeaderMapSearchDirIdx > 0) {
 // Handle cold misses of user includes in the presence of many header
 // maps.  We avoid searching perhaps thousands of header maps by
 // jumping directly to the correct one or jumping beyond all of them.
 else
 // In index => Start with a specific header map
 It = search_dir_nth(Iter->second);
 }
 }
-} else
+} else {
-CacheLookup.reset(/*NewStartIt=*/NextIt);
+CacheLookup.reset(RequestingModule, /*NewStartIt=*/NextIt);
+}
 SmallString<64> MappedName;
 // Check each directory in sequence to see if it contains this file.
 for (; It != search_dir_end(); ++It) {
 bool InUserSpecifiedSystemFramework = false;
 bool IsInHeaderMap = false;
 bool IsFrameworkFoundInDir = false;
-Optional<FileEntryRef> File = It->LookupFile(
+OptionalFileEntryRef File = It->LookupFile(
 Filename, *this, IncludeLoc, SearchPath, RelativePath, RequestingModule,
 SuggestedModule, InUserSpecifiedSystemFramework, IsFrameworkFoundInDir,
 IsInHeaderMap, MappedName, OpenFile);
 if (!MappedName.empty()) {
 assert(IsInHeaderMap && "MappedName should come from a header map");
 }
 bool FoundByHeaderMap = !IsMapped ? false : *IsMapped;
 if (!Includers.empty())
 diagnoseFrameworkInclude(
-Diags, IncludeLoc, Includers.front().second->getName(), Filename,
+Diags, IncludeLoc, Includers.front().second.getName(), Filename,
 &File->getFileEntry(), isAngled, FoundByHeaderMap);
 // Remember this location for the next lookup we do.
 cacheLookupSuccess(CacheLookup, It, IncludeLoc);
 return File;
 SmallString<128> ScratchFilename;
 ScratchFilename += IncludingHFI.Framework;
 ScratchFilename += '/';
 ScratchFilename += Filename;
-Optional<FileEntryRef> File = LookupFile(
+OptionalFileEntryRef File = LookupFile(
 ScratchFilename, IncludeLoc, /*isAngled=*/true, FromDir, &CurDir,
 Includers.front(), SearchPath, RelativePath, RequestingModule,
 SuggestedModule, IsMapped, /*IsFrameworkFound=*/nullptr);
 if (checkMSVCHeaderSearch(Diags, MSFE ? &MSFE->getFileEntry() : nullptr,
 return MSFE;
 }
 // Otherwise, didn't find it. Remember we didn't find this.
 CacheLookup.HitIt = search_dir_end();
-return None;
+return std::nullopt;
 }
 /// LookupSubframeworkHeader - Look up a subframework for the specified
 /// \#include file.  For example, if \#include'ing <HIToolbox/HIToolbox.h> from
 /// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox
 /// is a subframework within Carbon.framework.  If so, return the FileEntry
 /// for the designated file, otherwise return null.
-Optional<FileEntryRef> HeaderSearch::LookupSubframeworkHeader(
+OptionalFileEntryRef HeaderSearch::LookupSubframeworkHeader(
 StringRef Filename, const FileEntry *ContextFileEnt,
 SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
 Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule) {
 assert(ContextFileEnt && "No context file?");
 // Framework names must have a '/' in the filename.  Find it.
 // FIXME: Should we permit '\' on Windows?
 size_t SlashPos = Filename.find('/');
 if (SlashPos == StringRef::npos)
-return None;
+return std::nullopt;
 // Look up the base framework name of the ContextFileEnt.
 StringRef ContextName = ContextFileEnt->getName();
 // If the context info wasn't a framework, couldn't be a subframework.
 const unsigned DotFrameworkLen = 10;
 auto FrameworkPos = ContextName.find(".framework");
 if (FrameworkPos == StringRef::npos ||
 (ContextName[FrameworkPos + DotFrameworkLen] != '/' &&
 ContextName[FrameworkPos + DotFrameworkLen] != '\\'))
-return None;
+return std::nullopt;
 SmallString<1024> FrameworkName(ContextName.data(), ContextName.data() +
 FrameworkPos +
 DotFrameworkLen + 1);
 // Some other location?
 if (CacheLookup.second.Directory &&
 CacheLookup.first().size() == FrameworkName.size() &&
 memcmp(CacheLookup.first().data(), &FrameworkName[0],
 CacheLookup.first().size()) != 0)
-return None;
+return std::nullopt;
 // Cache subframework.
 if (!CacheLookup.second.Directory) {
 ++NumSubFrameworkLookups;
 // If the framework dir doesn't exist, we fail.
 auto Dir = FileMgr.getOptionalDirectoryRef(FrameworkName);
 if (!Dir)
-return None;
+return std::nullopt;
 // Otherwise, if it does, remember that this is the right direntry for this
 // framework.
 CacheLookup.second.Directory = Dir;
 }
 HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
 File = FileMgr.getOptionalFileRef(HeadersFilename, /*OpenFile=*/true);
 if (!File)
-return None;
+return std::nullopt;
 }
 // This file is a system header or C++ unfriendly if the old file is.
 //
 // Note that the temporary 'DirInfo' is required here, as either call to
 // of evaluation.
 unsigned DirInfo = getFileInfo(ContextFileEnt).DirInfo;
 getFileInfo(&File->getFileEntry()).DirInfo = DirInfo;
 FrameworkName.pop_back(); // remove the trailing '/'
-if (!findUsableModuleForFrameworkHeader(&File->getFileEntry(), FrameworkName,
+if (!findUsableModuleForFrameworkHeader(*File, FrameworkName,
 RequestingModule, SuggestedModule,
 /*IsSystem*/ false))
-return None;
+return std::nullopt;
 return *File;
 }
 //===----------------------------------------------------------------------===//
 return nullptr;
 return HFI;
 }
-bool HeaderSearch::isFileMultipleIncludeGuarded(const FileEntry *File) {
+bool HeaderSearch::isFileMultipleIncludeGuarded(const FileEntry *File) const {
 // Check if we've entered this file and found an include guard or #pragma
 // once. Note that we dor't check for #import, because that's not a property
 // of the file itself.
 if (auto *HFI = getExistingFileInfo(File))
 return HFI->isPragmaOnce || HFI->ControllingMacro ||
 FixUpDirectories.push_back(*Dir);
 } while (true);
 }
 ModuleMap::KnownHeader
-HeaderSearch::findModuleForHeader(const FileEntry *File, bool AllowTextual,
+HeaderSearch::findModuleForHeader(FileEntryRef File, bool AllowTextual,
 bool AllowExcluded) const {
 if (ExternalSource) {
 // Make sure the external source has handled header info about this file,
 // which includes whether the file is part of a module.
 (void)getExistingFileInfo(File);
 }
 return ModMap.findModuleForHeader(File, AllowTextual, AllowExcluded);
 }
 ArrayRef<ModuleMap::KnownHeader>
-HeaderSearch::findAllModulesForHeader(const FileEntry *File) const {
+HeaderSearch::findAllModulesForHeader(FileEntryRef File) const {
 if (ExternalSource) {
 // Make sure the external source has handled header info about this file,
 // which includes whether the file is part of a module.
 (void)getExistingFileInfo(File);
 }
 return ModMap.findAllModulesForHeader(File);
 }
-static bool suggestModule(HeaderSearch &HS, const FileEntry *File,
+ArrayRef<ModuleMap::KnownHeader>
+HeaderSearch::findResolvedModulesForHeader(const FileEntry *File) const {
+if (ExternalSource) {
+// Make sure the external source has handled header info about this file,
+// which includes whether the file is part of a module.
+(void)getExistingFileInfo(File);
+}
+return ModMap.findResolvedModulesForHeader(File);
+}
+static bool suggestModule(HeaderSearch &HS, FileEntryRef File,
 Module *RequestingModule,
 ModuleMap::KnownHeader *SuggestedModule) {
 ModuleMap::KnownHeader Module =
 HS.findModuleForHeader(File, /*AllowTextual*/true);
 return true;
 }
 bool HeaderSearch::findUsableModuleForHeader(
-const FileEntry *File, const DirectoryEntry *Root, Module *RequestingModule,
+FileEntryRef File, const DirectoryEntry *Root, Module *RequestingModule,
 ModuleMap::KnownHeader *SuggestedModule, bool IsSystemHeaderDir) {
-if (File && needModuleLookup(RequestingModule, SuggestedModule)) {
+if (needModuleLookup(RequestingModule, SuggestedModule)) {
 // If there is a module that corresponds to this header, suggest it.
-hasModuleMap(File->getName(), Root, IsSystemHeaderDir);
+hasModuleMap(File.getName(), Root, IsSystemHeaderDir);
 return suggestModule(*this, File, RequestingModule, SuggestedModule);
 }
 return true;
 }
 bool HeaderSearch::findUsableModuleForFrameworkHeader(
-const FileEntry *File, StringRef FrameworkName, Module *RequestingModule,
+FileEntryRef File, StringRef FrameworkName, Module *RequestingModule,
 ModuleMap::KnownHeader *SuggestedModule, bool IsSystemFramework) {
 // If we're supposed to suggest a module, look for one now.
 if (needModuleLookup(RequestingModule, SuggestedModule)) {
 // Find the top-level framework based on this framework.
 SmallVector<std::string, 4> SubmodulePath;
-Optional<DirectoryEntryRef> TopFrameworkDir =
+OptionalDirectoryEntryRef TopFrameworkDir =
 ::getTopFrameworkDir(FileMgr, FrameworkName, SubmodulePath);
 assert(TopFrameworkDir && "Could not find the top-most framework dir");
 // Determine the name of the top-level framework.
 StringRef ModuleName = llvm::sys::path::stem(TopFrameworkDir->getName());
 return suggestModule(*this, File, RequestingModule, SuggestedModule);
 }
 return true;
 }
-static const FileEntry *getPrivateModuleMap(const FileEntry *File,
+static const FileEntry *getPrivateModuleMap(FileEntryRef File,
 FileManager &FileMgr) {
-StringRef Filename = llvm::sys::path::filename(File->getName());
+StringRef Filename = llvm::sys::path::filename(File.getName());
-SmallString<128>  PrivateFilename(File->getDir()->getName());
+SmallString<128>  PrivateFilename(File.getDir().getName());
 if (Filename == "module.map")
 llvm::sys::path::append(PrivateFilename, "module_private.map");
 else if (Filename == "module.modulemap")
 llvm::sys::path::append(PrivateFilename, "module.private.modulemap");
 else
 if (auto File = FileMgr.getFile(PrivateFilename))
 return *File;
 return nullptr;
 }
-bool HeaderSearch::loadModuleMapFile(const FileEntry *File, bool IsSystem,
+bool HeaderSearch::loadModuleMapFile(FileEntryRef File, bool IsSystem,
 FileID ID, unsigned *Offset,
 StringRef OriginalModuleMapFile) {
 // Find the directory for the module. For frameworks, that may require going
 // up from the 'Modules' directory.
-Optional<DirectoryEntryRef> Dir;
+OptionalDirectoryEntryRef Dir;
 if (getHeaderSearchOpts().ModuleMapFileHomeIsCwd) {
 Dir = FileMgr.getOptionalDirectoryRef(".");
 } else {
 if (!OriginalModuleMapFile.empty()) {
 // We're building a preprocessed module map. Find or invent the directory
 if (!Dir) {
 auto FakeFile = FileMgr.getVirtualFileRef(OriginalModuleMapFile, 0, 0);
 Dir = FakeFile.getDir();
 }
 } else {
-// TODO: Replace with `Dir = File.getDir()` when `File` is switched to
+Dir = File.getDir();
-// `FileEntryRef`.
-Dir = FileMgr.getOptionalDirectoryRef(File->getDir()->getName());
 }
 assert(Dir && "parent must exist");
 StringRef DirName(Dir->getName());
 if (llvm::sys::path::filename(DirName) == "Modules") {
 }
 llvm_unreachable("Unknown load module map result");
 }
 HeaderSearch::LoadModuleMapResult
-HeaderSearch::loadModuleMapFileImpl(const FileEntry *File, bool IsSystem,
+HeaderSearch::loadModuleMapFileImpl(FileEntryRef File, bool IsSystem,
 DirectoryEntryRef Dir, 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;
 // This directory has a module map.
 return LMM_NewlyLoaded;
 }
-const FileEntry *
+OptionalFileEntryRef
-HeaderSearch::lookupModuleMapFile(const DirectoryEntry *Dir, bool IsFramework) {
+HeaderSearch::lookupModuleMapFile(DirectoryEntryRef Dir, bool IsFramework) {
 if (!HSOpts->ImplicitModuleMaps)
-return nullptr;
+return std::nullopt;
 // For frameworks, the preferred spelling is Modules/module.modulemap, but
 // module.map at the framework root is also accepted.
-SmallString<128> ModuleMapFileName(Dir->getName());
+SmallString<128> ModuleMapFileName(Dir.getName());
 if (IsFramework)
 llvm::sys::path::append(ModuleMapFileName, "Modules");
 llvm::sys::path::append(ModuleMapFileName, "module.modulemap");
-if (auto F = FileMgr.getFile(ModuleMapFileName))
+if (auto F = FileMgr.getOptionalFileRef(ModuleMapFileName))
 return *F;
 // Continue to allow module.map
-ModuleMapFileName = Dir->getName();
+ModuleMapFileName = Dir.getName();
 llvm::sys::path::append(ModuleMapFileName, "module.map");
-if (auto F = FileMgr.getFile(ModuleMapFileName))
+if (auto F = FileMgr.getOptionalFileRef(ModuleMapFileName))
 return *F;
 // For frameworks, allow to have a private module map with a preferred
 // spelling when a public module map is absent.
 if (IsFramework) {
-ModuleMapFileName = Dir->getName();
+ModuleMapFileName = Dir.getName();
 llvm::sys::path::append(ModuleMapFileName, "Modules",
 "module.private.modulemap");
-if (auto F = FileMgr.getFile(ModuleMapFileName))
+if (auto F = FileMgr.getOptionalFileRef(ModuleMapFileName))
 return *F;
 }
-return nullptr;
+return std::nullopt;
 }
 Module *HeaderSearch::loadFrameworkModule(StringRef Name, DirectoryEntryRef Dir,
 bool IsSystem) {
-if (Module *Module = ModMap.findModule(Name))
-return Module;
 // Try to load a module map file.
 switch (loadModuleMapFile(Dir, IsSystem, /*IsFramework*/true)) {
 case LMM_InvalidModuleMap:
 // Try to infer a module map from the framework directory.
 if (HSOpts->ImplicitModuleMaps)
 ModMap.inferFrameworkModule(Dir, IsSystem, /*Parent=*/nullptr);
 break;
-case LMM_AlreadyLoaded:
 case LMM_NoDirectory:
 return nullptr;
+case LMM_AlreadyLoaded:
 case LMM_NewlyLoaded:
 break;
 }
 return ModMap.findModule(Name);
 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)) {
+if (OptionalFileEntryRef ModuleMapFile =
+lookupModuleMapFile(Dir, IsFramework)) {
 LoadModuleMapResult Result =
-loadModuleMapFileImpl(ModuleMapFile, IsSystem, Dir);
+loadModuleMapFileImpl(*ModuleMapFile, IsSystem, Dir);
 // 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;
 for (DirectoryLookup &DL : search_dir_range()) {
 bool IsSystem = DL.isSystemHeaderDirectory();
 if (DL.isFramework()) {
 std::error_code EC;
 SmallString<128> DirNative;
-llvm::sys::path::native(DL.getFrameworkDir()->getName(), DirNative);
+llvm::sys::path::native(DL.getFrameworkDirRef()->getName(), DirNative);
 // Search each of the ".framework" directories to load them as modules.
 llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
 DirEnd;
 if (SearchDir.haveSearchedAllModuleMaps())
 return;
 std::error_code EC;
-SmallString<128> Dir = SearchDir.getDir()->getName();
+SmallString<128> Dir = SearchDir.getDirRef()->getName();
 FileMgr.makeAbsolutePath(Dir);
 SmallString<128> DirNative;
 llvm::sys::path::native(Dir, DirNative);
 llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
 for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
 Dir != DirEnd && !EC; Dir.increment(EC)) {
+if (Dir->type() == llvm::sys::fs::file_type::regular_file)
+continue;
 bool IsFramework = llvm::sys::path::extension(Dir->path()) == ".framework";
 if (IsFramework == SearchDir.isFramework())
 loadModuleMapFile(Dir->path(), SearchDir.isSystemHeaderDirectory(),
 SearchDir.isFramework());
 }
 SearchDir.setSearchedAllModuleMaps(true);
 }
 std::string HeaderSearch::suggestPathToFileForDiagnostics(
-const FileEntry *File, llvm::StringRef MainFile, bool *IsSystem) {
+const FileEntry *File, llvm::StringRef MainFile, bool *IsAngled) const {
 // FIXME: We assume that the path name currently cached in the FileEntry is
 // the most appropriate one for this analysis (and that it's spelled the
 // same way as the corresponding header search path).
 return suggestPathToFileForDiagnostics(File->getName(), /*WorkingDir=*/"",
-MainFile, IsSystem);
+MainFile, IsAngled);
 }
 std::string HeaderSearch::suggestPathToFileForDiagnostics(
 llvm::StringRef File, llvm::StringRef WorkingDir, llvm::StringRef MainFile,
-bool *IsSystem) {
+bool *IsAngled) const {
 using namespace llvm::sys;
+llvm::SmallString<32> FilePath = File;
+// remove_dots switches to backslashes on windows as a side-effect!
+// We always want to suggest forward slashes for includes.
+// (not remove_dots(..., posix) as that misparses windows paths).
+path::remove_dots(FilePath, /*remove_dot_dot=*/true);
+path::native(FilePath, path::Style::posix);
+File = FilePath;
 unsigned BestPrefixLength = 0;
 // Checks whether `Dir` is a strict path prefix of `File`. If so and that's
 // the longest prefix we've seen so for it, returns true and updates the
 // `BestPrefixLength` accordingly.
-auto CheckDir = [&](llvm::StringRef Dir) -> bool {
+auto CheckDir = [&](llvm::SmallString<32> Dir) -> bool {
-llvm::SmallString<32> DirPath(Dir.begin(), Dir.end());
 if (!WorkingDir.empty() && !path::is_absolute(Dir))
-fs::make_absolute(WorkingDir, DirPath);
+fs::make_absolute(WorkingDir, Dir);
-path::remove_dots(DirPath, /*remove_dot_dot=*/true);
+path::remove_dots(Dir, /*remove_dot_dot=*/true);
-Dir = DirPath;
 for (auto NI = path::begin(File), NE = path::end(File),
 DI = path::begin(Dir), DE = path::end(Dir);
-/*termination condition in loop*/; ++NI, ++DI) {
+NI != NE; ++NI, ++DI) {
-// '.' components in File are ignored.
-while (NI != NE && *NI == ".")
-++NI;
-if (NI == NE)
-break;
-// '.' components in Dir are ignored.
-while (DI != DE && *DI == ".")
-++DI;
 if (DI == DE) {
-// Dir is a prefix of File, up to '.' components and choice of path
+// Dir is a prefix of File, up to choice of path separators.
-// separators.
 unsigned PrefixLength = NI - path::begin(File);
 if (PrefixLength > BestPrefixLength) {
 BestPrefixLength = PrefixLength;
 return true;
 }
 };
 bool BestPrefixIsFramework = false;
 for (const DirectoryLookup &DL : search_dir_range()) {
 if (DL.isNormalDir()) {
-StringRef Dir = DL.getDir()->getName();
+StringRef Dir = DL.getDirRef()->getName();
 if (CheckDir(Dir)) {
-if (IsSystem)
+if (IsAngled)
-*IsSystem = BestPrefixLength && isSystem(DL.getDirCharacteristic());
+*IsAngled = BestPrefixLength && isSystem(DL.getDirCharacteristic());
 BestPrefixIsFramework = false;
 }
 } else if (DL.isFramework()) {
-StringRef Dir = DL.getFrameworkDir()->getName();
+StringRef Dir = DL.getFrameworkDirRef()->getName();
 if (CheckDir(Dir)) {
-if (IsSystem)
+// Framework includes by convention use <>.
-*IsSystem = BestPrefixLength && isSystem(DL.getDirCharacteristic());
+if (IsAngled)
+*IsAngled = BestPrefixLength;
 BestPrefixIsFramework = true;
 }
 }
 }
 // Try to shorten include path using TUs directory, if we couldn't find any
 // suitable prefix in include search paths.
 if (!BestPrefixLength && CheckDir(path::parent_path(MainFile))) {
-if (IsSystem)
+if (IsAngled)
-*IsSystem = false;
+*IsAngled = false;
 BestPrefixIsFramework = false;
 }
 // Try resolving resulting filename via reverse search in header maps,
 // key from header name is user preferred name for the include file.

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Lex/HeaderSearch.cpp @ 252:1f2b6ac9f198 llvm-original