@@ -335,9 +335,10 @@ class SymbolCollector::HeaderFileURICache {
335335 }
336336
337337 struct FrameworkHeaderPath {
338- // Path to the framework directory containing the Headers/PrivateHeaders
339- // directories e.g. /Frameworks/Foundation.framework/
340- llvm::StringRef HeadersParentDir;
338+ // Path to the frameworks directory containing the .framework directory.
339+ llvm::StringRef FrameworkParentDir;
340+ // Name of the framework.
341+ llvm::StringRef FrameworkName;
341342 // Subpath relative to the Headers or PrivateHeaders dir, e.g. NSObject.h
342343 // Note: This is NOT relative to the `HeadersParentDir`.
343344 llvm::StringRef HeaderSubpath;
@@ -351,19 +352,17 @@ class SymbolCollector::HeaderFileURICache {
351352 path::reverse_iterator I = path::rbegin (Path);
352353 path::reverse_iterator Prev = I;
353354 path::reverse_iterator E = path::rend (Path);
355+ FrameworkHeaderPath HeaderPath;
354356 while (I != E) {
355- if (*I == " Headers" ) {
356- FrameworkHeaderPath HeaderPath;
357- HeaderPath.HeadersParentDir = Path.substr (0 , I - E);
357+ if (*I == " Headers" || *I == " PrivateHeaders" ) {
358358 HeaderPath.HeaderSubpath = Path.substr (Prev - E);
359- HeaderPath.IsPrivateHeader = false ;
360- return HeaderPath;
361- }
362- if (*I == " PrivateHeaders" ) {
363- FrameworkHeaderPath HeaderPath;
364- HeaderPath.HeadersParentDir = Path.substr (0 , I - E);
365- HeaderPath.HeaderSubpath = Path.substr (Prev - E);
366- HeaderPath.IsPrivateHeader = true ;
359+ HeaderPath.IsPrivateHeader = *I == " PrivateHeaders" ;
360+ if (++I == E)
361+ break ;
362+ HeaderPath.FrameworkName = *I;
363+ if (!HeaderPath.FrameworkName .consume_back (" .framework" ))
364+ break ;
365+ HeaderPath.FrameworkParentDir = Path.substr (0 , I - E);
367366 return HeaderPath;
368367 }
369368 Prev = I;
@@ -379,26 +378,27 @@ class SymbolCollector::HeaderFileURICache {
379378 // <Foundation/NSObject_Private.h> which should be used instead of directly
380379 // importing the header.
381380 std::optional<std::string>
382- getFrameworkUmbrellaSpelling (llvm::StringRef Framework,
383- const HeaderSearch &HS,
381+ getFrameworkUmbrellaSpelling (const HeaderSearch &HS,
384382 FrameworkHeaderPath &HeaderPath) {
383+ StringRef Framework = HeaderPath.FrameworkName ;
385384 auto Res = CacheFrameworkToUmbrellaHeaderSpelling.try_emplace (Framework);
386385 auto *CachedSpelling = &Res.first ->second ;
387386 if (!Res.second ) {
388387 return HeaderPath.IsPrivateHeader ? CachedSpelling->PrivateHeader
389388 : CachedSpelling->PublicHeader ;
390389 }
391- SmallString<256 > UmbrellaPath (HeaderPath.HeadersParentDir );
392- llvm::sys::path::append (UmbrellaPath, " Headers" , Framework + " .h" );
390+ SmallString<256 > UmbrellaPath (HeaderPath.FrameworkParentDir );
391+ llvm::sys::path::append (UmbrellaPath, Framework + " .framework" , " Headers" ,
392+ Framework + " .h" );
393393
394394 llvm::vfs::Status Status;
395395 auto StatErr = HS.getFileMgr ().getNoncachedStatValue (UmbrellaPath, Status);
396396 if (!StatErr)
397397 CachedSpelling->PublicHeader = llvm::formatv (" <{0}/{0}.h>" , Framework);
398398
399- UmbrellaPath = HeaderPath.HeadersParentDir ;
400- llvm::sys::path::append (UmbrellaPath, " PrivateHeaders " ,
401- Framework + " _Private.h" );
399+ UmbrellaPath = HeaderPath.FrameworkParentDir ;
400+ llvm::sys::path::append (UmbrellaPath, Framework + " .framework " ,
401+ " PrivateHeaders " , Framework + " _Private.h" );
402402
403403 StatErr = HS.getFileMgr ().getNoncachedStatValue (UmbrellaPath, Status);
404404 if (!StatErr)
@@ -414,8 +414,7 @@ class SymbolCollector::HeaderFileURICache {
414414 // give <Foundation/Foundation.h> if the umbrella header exists, otherwise
415415 // <Foundation/NSObject.h>.
416416 std::optional<llvm::StringRef>
417- getFrameworkHeaderIncludeSpelling (FileEntryRef FE, llvm::StringRef Framework,
418- HeaderSearch &HS) {
417+ getFrameworkHeaderIncludeSpelling (FileEntryRef FE, HeaderSearch &HS) {
419418 auto Res = CachePathToFrameworkSpelling.try_emplace (FE.getName ());
420419 auto *CachedHeaderSpelling = &Res.first ->second ;
421420 if (!Res.second )
@@ -429,13 +428,15 @@ class SymbolCollector::HeaderFileURICache {
429428 return std::nullopt ;
430429 }
431430 if (auto UmbrellaSpelling =
432- getFrameworkUmbrellaSpelling (Framework, HS, *HeaderPath)) {
431+ getFrameworkUmbrellaSpelling (HS, *HeaderPath)) {
433432 *CachedHeaderSpelling = *UmbrellaSpelling;
434433 return llvm::StringRef (*CachedHeaderSpelling);
435434 }
436435
437436 *CachedHeaderSpelling =
438- llvm::formatv (" <{0}/{1}>" , Framework, HeaderPath->HeaderSubpath ).str ();
437+ llvm::formatv (" <{0}/{1}>" , HeaderPath->FrameworkName ,
438+ HeaderPath->HeaderSubpath )
439+ .str ();
439440 return llvm::StringRef (*CachedHeaderSpelling);
440441 }
441442
@@ -454,11 +455,8 @@ class SymbolCollector::HeaderFileURICache {
454455 // Framework headers are spelled as <FrameworkName/Foo.h>, not
455456 // "path/FrameworkName.framework/Headers/Foo.h".
456457 auto &HS = PP->getHeaderSearchInfo ();
457- if (const auto *HFI = HS.getExistingFileInfo (*FE))
458- if (!HFI->Framework .empty ())
459- if (auto Spelling =
460- getFrameworkHeaderIncludeSpelling (*FE, HFI->Framework , HS))
461- return *Spelling;
458+ if (auto Spelling = getFrameworkHeaderIncludeSpelling (*FE, HS))
459+ return *Spelling;
462460
463461 if (!tooling::isSelfContainedHeader (*FE, PP->getSourceManager (),
464462 PP->getHeaderSearchInfo ())) {
0 commit comments