[clangd][NFCI] Store TUPath inside ParsedAST

[kadircet]

Summary

Lots of features built on top of ASTs require getting back to the path
of the TU and they used lossy conversion from file ids using sourcemanager.
This patch preserves the file path passed by the caller inside ParsedAST for
later use.

[ilya-biryukov]

I want to understand the trade-offs a bit better.

• what are the actual differences between the file paths passed to TU and the canonical path in source manager?
• what issues does having these differences result in?

Having some tests that illustrate the difference in a real-world setting would be helpful too.

We would still have to go through source manager to produce results for anything but the main file.
This means that after this change we effectively add complexity the path handling by adding an extra code path for the main file.
Moreover, it's the most common path we return, so we could make any problems with the paths from the source manager appear less frequently and, hence, harder to notice and diagnose.

[ilya-biryukov]

LGTM and a few nits. Could you please add a summary of our offline discussion here?

clang-tools-extra/clangd/ParsedAST.cpp

763

NIT: use Path.
this allows the callers to avoid an extra allocation, e.g. if they already allocated a std::string and they can std::move into the constructor.

clang-tools-extra/clangd/ParsedAST.h

112

NIT: could you add a comment how this is used, e.g. this path is used as a hint when canonicalize the path.
Also useful to document that we expect this to be absolute/"canonical".

[kadircet]

as discussed offline, this patch stores the filepath provided by the client (e.g. vscode) which is usually the filepath seen by the user, inside the ParsedAST and later on uses that when a hint is needed for translating filepaths coming from sourcemanager into uris.
this gets rid of the extra canonicalization needed for the main file path (which could fail when we don't have a current working directory set, i.e. in tests) and also does always the "right" thing as all the files should be relative to the workspace of the main file path seen by the user, not the version clangd derives somehow.

clang-tools-extra/clangd/ParsedAST.cpp

763

this is a private constructor and public interface also receives a stringref and none of the production callers actually have an extra copy of the filename lying around. so i'd rather keep it as is.

clang-tools-extra/clangd/ParsedAST.h

112

i'd rather not complicate the wording here. i think mentioning the fact that this is the filepath as provided by the caller is enough. being used as a hint for canonicalization of other paths is something specific to the application (and is a result of being the path provided by caller anyway.)

clang-tools-extra/clangd/Hover.cpp

llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
   }
   const auto &TB = AST.getTokens();
   auto TokensTouchingCursor = syntax::spelledTokensTouching(*CurLoc, TB);
   // Early exit if there were no tokens around the cursor.
   if (TokensTouchingCursor.empty())
     return llvm::None;
 
   // Show full header file path if cursor is on include directive.
-  if (const auto MainFilePath =
-          getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM)) {
-    for (const auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
-      if (Inc.Resolved.empty() || Inc.HashLine != Pos.line)
-        continue;
-      HoverInfo HI;
-      HI.Name = std::string(llvm::sys::path::filename(Inc.Resolved));
-      // FIXME: We don't have a fitting value for Kind.
-      HI.Definition =
-          URIForFile::canonicalize(Inc.Resolved, *MainFilePath).file().str();
-      HI.DefinitionLanguage = "";
-      return HI;
-    }
-  }
+        URIForFile::canonicalize(Inc.Resolved, AST.tuPath()).file().str();
 
   // To be used as a backup for highlighting the selected token, we use back as
   // it aligns better with biases elsewhere (editors tend to send the position
   // for the left of the hovered token).
   CharSourceRange HighlightRange =
       TokensTouchingCursor.back().range(SM).toCharRange(SM);
   llvm::Optional<HoverInfo> HI;
   // Macros and deducedtype only works on identifiers and auto/decltype keywords

clang-tools-extra/clangd/ParsedAST.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H
 
 #include "CollectMacros.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "Headers.h"
 #include "Preamble.h"
 #include "index/CanonicalIncludes.h"
+#include "support/Path.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 #include <string>
public:
   const std::vector<PragmaMark> &getMarks() const;
   /// Tokens recorded while parsing the main file.
   /// (!) does not have tokens from the preamble.
   const syntax::TokenBuffer &getTokens() const { return Tokens; }
 
   /// Returns the version of the ParseInputs this AST was built from.
   llvm::StringRef version() const { return Version; }
 
+  /// Returns the path passed by the caller when building this AST.
+  PathRef tuPath() const { return TUPath; }
+
   /// Returns the version of the ParseInputs used to build Preamble part of this
   /// AST. Might be None if no Preamble is used.
   llvm::Optional<llvm::StringRef> preambleVersion() const;
 
   const HeuristicResolver *getHeuristicResolver() const {
     return Resolver.get();
   }
 
 private:
-  ParsedAST(llvm::StringRef Version,
+  ParsedAST(PathRef TUPath, llvm::StringRef Version,
             std::shared_ptr<const PreambleData> Preamble,
             std::unique_ptr<CompilerInstance> Clang,
             std::unique_ptr<FrontendAction> Action, syntax::TokenBuffer Tokens,
             MainFileMacros Macros, std::vector<PragmaMark> Marks,
             std::vector<Decl *> LocalTopLevelDecls,
             llvm::Optional<std::vector<Diag>> Diags, IncludeStructure Includes,
             CanonicalIncludes CanonIncludes);
 
+  Path TUPath;
   std::string Version;
   // In-memory preambles must outlive the AST, it is important that this member
   // goes before Clang and Action.
   std::shared_ptr<const PreambleData> Preamble;
   // We store an "incomplete" FrontendAction (i.e. no EndSourceFile was called
   // on it) and CompilerInstance used to run it. That way we don't have to do
   // complex memory management of all Clang structures on our own. (They are
   // stored in CompilerInstance and cleaned up by

clang-tools-extra/clangd/ParsedAST.cpp

if (Preamble)
       Diags->insert(Diags->end(), Preamble->Diags.begin(),
                     Preamble->Diags.end());
     // Finally, add diagnostics coming from the AST.
     {
       std::vector<Diag> D = ASTDiags.take(CTContext.getPointer());
       Diags->insert(Diags->end(), D.begin(), D.end());
     }
   }
-  ParsedAST Result(Inputs.Version, std::move(Preamble), std::move(Clang),
-                   std::move(Action), std::move(Tokens), std::move(Macros),
-                   std::move(Marks), std::move(ParsedDecls), std::move(Diags),
-                   std::move(Includes), std::move(CanonIncludes));
+  ParsedAST Result(Filename, Inputs.Version, std::move(Preamble),
+                   std::move(Clang), std::move(Action), std::move(Tokens),
+                   std::move(Macros), std::move(Marks), std::move(ParsedDecls),
+                   std::move(Diags), std::move(Includes),
+                   std::move(CanonIncludes));
   if (Result.Diags) {
     auto UnusedHeadersDiags =
         issueUnusedIncludesDiagnostics(Result, Inputs.Contents);
     Result.Diags->insert(Result.Diags->end(),
                          make_move_iterator(UnusedHeadersDiags.begin()),
                          make_move_iterator(UnusedHeadersDiags.end()));
   }
   return Result;

 const IncludeStructure &ParsedAST::getIncludeStructure() const {
   return Includes;
 }
 
 const CanonicalIncludes &ParsedAST::getCanonicalIncludes() const {
   return CanonIncludes;
 }
 
-ParsedAST::ParsedAST(llvm::StringRef Version,
+ParsedAST::ParsedAST(PathRef TUPath, llvm::StringRef Version,
                      std::shared_ptr<const PreambleData> Preamble,
                      std::unique_ptr<CompilerInstance> Clang,
                      std::unique_ptr<FrontendAction> Action,
                      syntax::TokenBuffer Tokens, MainFileMacros Macros,
                      std::vector<PragmaMark> Marks,
                      std::vector<Decl *> LocalTopLevelDecls,
                      llvm::Optional<std::vector<Diag>> Diags,
                      IncludeStructure Includes, CanonicalIncludes CanonIncludes)
-    : Version(Version), Preamble(std::move(Preamble)), Clang(std::move(Clang)),
-      Action(std::move(Action)), Tokens(std::move(Tokens)),
-      Macros(std::move(Macros)), Marks(std::move(Marks)),
-      Diags(std::move(Diags)),
+    : TUPath(TUPath), Version(Version), Preamble(std::move(Preamble)),
+      Clang(std::move(Clang)), Action(std::move(Action)),
+      Tokens(std::move(Tokens)), Macros(std::move(Macros)),
+      Marks(std::move(Marks)), Diags(std::move(Diags)),
       LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
       Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
   Resolver = std::make_unique<HeuristicResolver>(getASTContext());
   assert(this->Clang);
   assert(this->Action);
 }
 
 llvm::Optional<llvm::StringRef> ParsedAST::preambleVersion() const {
   if (!Preamble)
     return llvm::None;
   return llvm::StringRef(Preamble->Version);
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/XRefs.h

 
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "index/Index.h"
 #include "index/SymbolID.h"
 #include "support/Path.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 namespace clang {
 namespace syntax {
 class Token;
 class TokenBuffer;
 } // namespace syntax
std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
                                           const SymbolIndex *Index = nullptr);
 
 // Tries to provide a textual fallback for locating a symbol by looking up the
 // word under the cursor as a symbol name in the index.
 // The aim is to pick up references to symbols in contexts where
 // AST-based resolution does not work, such as comments, strings, and PP
 // disabled regions.
 // (This is for internal use by locateSymbolAt, and is exposed for testing).
-std::vector<LocatedSymbol>
-locateSymbolTextually(const SpelledWord &Word, ParsedAST &AST,
-                      const SymbolIndex *Index, const std::string &MainFilePath,
+std::vector<LocatedSymbol> locateSymbolTextually(const SpelledWord &Word,
+                                                 ParsedAST &AST,
+                                                 const SymbolIndex *Index,
+                                                 llvm::StringRef MainFilePath,
                                                  ASTNodeKind NodeKind);
 
 // Try to find a proximate occurrence of `Word` as an identifier, which can be
 // used to resolve it.
 // (This is for internal use by locateSymbolAt, and is exposed for testing).
 const syntax::Token *findNearbyIdentifier(const SpelledWord &Word,
                                           const syntax::TokenBuffer &TB);
 
 /// Get all document links

clang-tools-extra/clangd/XRefs.cpp

auto Overrides = findImplementors(VirtualMethods, RelationKind::OverriddenBy,
                                     Index, MainFilePath);
   Result.insert(Result.end(), Overrides.begin(), Overrides.end());
   return Result;
 }
 
 std::vector<LocatedSymbol> locateSymbolForType(const ParsedAST &AST,
                                                const QualType &Type) {
   const auto &SM = AST.getSourceManager();
-  auto MainFilePath =
-      getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-  if (!MainFilePath) {
-    elog("Failed to get a path for the main file, so no symbol.");
-    return {};
-  }
+  auto MainFilePath = AST.tuPath();
 
   // FIXME: this sends unique_ptr<Foo> to unique_ptr<T>.
   // Likely it would be better to send it to Foo (heuristically) or to both.
   auto Decls = targetDecl(DynTypedNode::create(Type.getNonReferenceType()),
                           DeclRelation::TemplatePattern | DeclRelation::Alias,
                           AST.getHeuristicResolver());
   if (Decls.empty())
     return {};
 
   std::vector<LocatedSymbol> Results;
   const auto &ASTContext = AST.getASTContext();
 
   for (const NamedDecl *D : Decls) {
     D = getPreferredDecl(D);
 
-    auto Loc = makeLocation(ASTContext, nameLocation(*D, SM), *MainFilePath);
+    auto Loc = makeLocation(ASTContext, nameLocation(*D, SM), MainFilePath);
     if (!Loc)
       continue;
 
     Results.emplace_back();
     Results.back().Name = printName(ASTContext, *D);
     Results.back().PreferredDeclaration = *Loc;
     Results.back().ID = getSymbolID(D);
     if (const NamedDecl *Def = getDefinition(D))
       Results.back().Definition =
-          makeLocation(ASTContext, nameLocation(*Def, SM), *MainFilePath);
+          makeLocation(ASTContext, nameLocation(*Def, SM), MainFilePath);
   }
 
   return Results;
 }
 
 bool tokenSpelledAt(SourceLocation SpellingLoc, const syntax::TokenBuffer &TB) {
   auto ExpandedTokens = TB.expandedTokens(
       TB.sourceManager().getMacroArgExpandedLocation(SpellingLoc));
return NodeKind.isSame(ASTNodeKind::getFromNodeKind<OverloadExpr>()) ||
          NodeKind.isSame(
              ASTNodeKind::getFromNodeKind<CXXDependentScopeMemberExpr>()) ||
          NodeKind.isSame(
              ASTNodeKind::getFromNodeKind<DependentScopeDeclRefExpr>());
 }
 
 } // namespace
 
-std::vector<LocatedSymbol>
-locateSymbolTextually(const SpelledWord &Word, ParsedAST &AST,
-                      const SymbolIndex *Index, const std::string &MainFilePath,
+std::vector<LocatedSymbol> locateSymbolTextually(const SpelledWord &Word,
+                                                 ParsedAST &AST,
+                                                 const SymbolIndex *Index,
+                                                 llvm::StringRef MainFilePath,
                                                  ASTNodeKind NodeKind) {
   // Don't use heuristics if this is a real identifier, or not an
   // identifier.
   // Exception: dependent names, because those may have useful textual
   // matches that AST-based heuristics cannot find.
   if ((Word.ExpandedToken && !isDependentName(NodeKind)) ||
       !Word.LikelyIdentifier || !Index)
     return {};
   // We don't want to handle words in string literals. (It'd be nice to list
   // *allowed* token kinds explicitly, but comment Tokens aren't retained).
   if (Word.PartOfSpelledToken &&
       isStringLiteral(Word.PartOfSpelledToken->kind()))
     return {};
 
   const auto &SM = AST.getSourceManager();
   // Look up the selected word in the index.
   FuzzyFindRequest Req;
   Req.Query = Word.Text.str();
-  Req.ProximityPaths = {MainFilePath};
+  Req.ProximityPaths = {MainFilePath.str()};
   // Find the namespaces to query by lexing the file.
   Req.Scopes =
       visibleNamespaces(sourcePrefix(Word.Location, SM), AST.getLangOpts());
   // FIXME: For extra strictness, consider AnyScope=false.
   Req.AnyScope = true;
   // We limit the results to 3 further below. This limit is to avoid fetching
   // too much data, while still likely having enough for 3 results to remain
   // after additional filtering.
vlog(
         BestTok->location().printToString(SM));
 
   return BestTok;
 }
 
 std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
                                           const SymbolIndex *Index) {
   const auto &SM = AST.getSourceManager();
-  auto MainFilePath =
-      getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-  if (!MainFilePath) {
-    elog("Failed to get a path for the main file, so no references");
-    return {};
-  }
+  auto MainFilePath = AST.tuPath();
 
-  if (auto File = locateFileReferent(Pos, AST, *MainFilePath))
+  if (auto File = locateFileReferent(Pos, AST, MainFilePath))
     return {std::move(*File)};
 
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     elog("locateSymbolAt failed to convert position to source location: {0}",
          CurLoc.takeError());
     return {};
   }
 
   const syntax::Token *TouchedIdentifier = nullptr;
   auto TokensTouchingCursor =
       syntax::spelledTokensTouching(*CurLoc, AST.getTokens());
   for (const syntax::Token &Tok : TokensTouchingCursor) {
     if (Tok.kind() == tok::identifier) {
-      if (auto Macro = locateMacroReferent(Tok, AST, *MainFilePath))
+      if (auto Macro = locateMacroReferent(Tok, AST, MainFilePath))
         // Don't look at the AST or index if we have a macro result.
         // (We'd just return declarations referenced from the macro's
         // expansion.)
         return {*std::move(Macro)};
 
       TouchedIdentifier = &Tok;
       break;
     }
 
     if (Tok.kind() == tok::kw_auto || Tok.kind() == tok::kw_decltype) {
       // go-to-definition on auto should find the definition of the deduced
       // type, if possible
       if (auto Deduced = getDeducedType(AST.getASTContext(), Tok.location())) {
         auto LocSym = locateSymbolForType(AST, *Deduced);
         if (!LocSym.empty())
           return LocSym;
       }
     }
   }
 
   ASTNodeKind NodeKind;
   auto ASTResults = locateASTReferent(*CurLoc, TouchedIdentifier, AST,
-                                      *MainFilePath, Index, NodeKind);
+                                      MainFilePath, Index, NodeKind);
   if (!ASTResults.empty())
     return ASTResults;
 
   // If the cursor can't be resolved directly, try fallback strategies.
   auto Word =
       SpelledWord::touching(*CurLoc, AST.getTokens(), AST.getLangOpts());
   if (Word) {
     // Is the same word nearby a real identifier that might refer to something?
     if (const syntax::Token *NearbyIdent =
             findNearbyIdentifier(*Word, AST.getTokens())) {
-      if (auto Macro = locateMacroReferent(*NearbyIdent, AST, *MainFilePath)) {
+      if (auto Macro = locateMacroReferent(*NearbyIdent, AST, MainFilePath)) {
         log("Found macro definition heuristically using nearby identifier {0}",
             Word->Text);
         return {*std::move(Macro)};
       }
       ASTResults = locateASTReferent(NearbyIdent->location(), NearbyIdent, AST,
-                                     *MainFilePath, Index, NodeKind);
+                                     MainFilePath, Index, NodeKind);
       if (!ASTResults.empty()) {
         log("Found definition heuristically using nearby identifier {0}",
             NearbyIdent->text(SM));
         return ASTResults;
       }
       vlog("No definition found using nearby identifier {0} at {1}", Word->Text,
            Word->Location.printToString(SM));
     }
     // No nearby word, or it didn't refer to anything either. Try the index.
     auto TextualResults =
-        locateSymbolTextually(*Word, AST, Index, *MainFilePath, NodeKind);
+        locateSymbolTextually(*Word, AST, Index, MainFilePath, NodeKind);
     if (!TextualResults.empty())
       return TextualResults;
   }
 
   return {};
 }
 
 std::vector<DocumentLink> getDocumentLinks(ParsedAST &AST) {
   const auto &SM = AST.getSourceManager();
-  auto MainFilePath =
-      getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-  if (!MainFilePath) {
-    elog("Failed to get a path for the main file, so no links");
-    return {};
-  }
 
   std::vector<DocumentLink> Result;
   for (auto &Inc : AST.getIncludeStructure().MainFileIncludes) {
     if (Inc.Resolved.empty())
       continue;
     auto HashLoc = SM.getComposedLoc(SM.getMainFileID(), Inc.HashOffset);
     const auto *HashTok = AST.getTokens().spelledTokenAt(HashLoc);
     assert(HashTok && "got inclusion at wrong offset");
     const auto *IncludeTok = std::next(HashTok);
     const auto *FileTok = std::next(IncludeTok);
     // FileTok->range is not sufficient here, as raw lexing wouldn't yield
     // correct tokens for angled filenames. Hence we explicitly use
     // Inc.Written's length.
     auto FileRange =
         syntax::FileRange(SM, FileTok->location(), Inc.Written.length())
             .toCharRange(SM);
 
     Result.push_back(
         DocumentLink({halfOpenToRange(SM, FileRange),
-                      URIForFile::canonicalize(Inc.Resolved, *MainFilePath)}));
+                      URIForFile::canonicalize(Inc.Resolved, AST.tuPath())}));
   }
 
   return Result;
 }
 
 namespace {
 
 /// Collects references to symbols within the main file.

 std::vector<LocatedSymbol> findImplementations(ParsedAST &AST, Position Pos,
                                                const SymbolIndex *Index) {
   // We rely on index to find the implementations in subclasses.
   // FIXME: Index can be stale, so we may loose some latest results from the
   // main file.
   if (!Index)
     return {};
   const SourceManager &SM = AST.getSourceManager();
-  auto MainFilePath =
-      getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-  if (!MainFilePath) {
-    elog("Failed to get a path for the main file, so no implementations.");
-    return {};
-  }
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     elog("Failed to convert position to source location: {0}",
          CurLoc.takeError());
     return {};
   }
   DeclRelationSet Relations =
       DeclRelation::TemplatePattern | DeclRelation::Alias;
   llvm::DenseSet<SymbolID> IDs;
   RelationKind QueryKind = RelationKind::OverriddenBy;
   for (const NamedDecl *ND : getDeclAtPosition(AST, *CurLoc, Relations)) {
     if (const auto *CXXMD = llvm::dyn_cast<CXXMethodDecl>(ND)) {
       if (CXXMD->isVirtual()) {
         IDs.insert(getSymbolID(ND));
         QueryKind = RelationKind::OverriddenBy;
       }
     } else if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
       IDs.insert(getSymbolID(RD));
       QueryKind = RelationKind::BaseOf;
     }
   }
-  return findImplementors(std::move(IDs), QueryKind, Index, *MainFilePath);
+  return findImplementors(std::move(IDs), QueryKind, Index, AST.tuPath());
 }
 
 namespace {
 // Recursively finds all the overridden methods of `CMD` in complete type
 // hierarchy.
 void getOverriddenMethods(const CXXMethodDecl *CMD,
                           llvm::DenseSet<SymbolID> &OverriddenMethods) {
   if (!CMD)
     return;
   for (const CXXMethodDecl *Base : CMD->overridden_methods()) {
     if (auto ID = getSymbolID(Base))
       OverriddenMethods.insert(ID);
     getOverriddenMethods(Base, OverriddenMethods);
   }
 }
 } // namespace
 
 ReferencesResult findReferences(ParsedAST &AST, Position Pos, uint32_t Limit,
                                 const SymbolIndex *Index) {
   ReferencesResult Results;
   const SourceManager &SM = AST.getSourceManager();
-  auto MainFilePath =
-      getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-  if (!MainFilePath) {
-    elog("Failed to get a path for the main file, so no references");
-    return Results;
-  }
-  auto URIMainFile = URIForFile::canonicalize(*MainFilePath, *MainFilePath);
+  auto MainFilePath = AST.tuPath();
+  auto URIMainFile = URIForFile::canonicalize(MainFilePath, MainFilePath);
   auto CurLoc = sourceLocationInMainFile(SM, Pos);
   if (!CurLoc) {
     llvm::consumeError(CurLoc.takeError());
     return {};
   }
 
   llvm::DenseSet<SymbolID> IDsToQuery, OverriddenMethods;
 
if (Macro) {
     if (Index && !OverriddenBy.Subjects.empty()) {
       Index->relations(OverriddenBy, [&](const SymbolID &Subject,
                                          const Symbol &Object) {
         if (Limit && Results.References.size() >= Limit) {
           Results.HasMore = true;
           return;
         }
         const auto LSPLocDecl =
-            toLSPLocation(Object.CanonicalDeclaration, *MainFilePath);
-        const auto LSPLocDef = toLSPLocation(Object.Definition, *MainFilePath);
+            toLSPLocation(Object.CanonicalDeclaration, MainFilePath);
+        const auto LSPLocDef = toLSPLocation(Object.Definition, MainFilePath);
         if (LSPLocDecl && LSPLocDecl != LSPLocDef) {
           ReferencesResult::Reference Result;
           Result.Loc = std::move(*LSPLocDecl);
           Result.Attributes =
               ReferencesResult::Declaration | ReferencesResult::Override;
           Results.References.push_back(std::move(Result));
         }
         if (LSPLocDef) {
if (Limit) {
         // return the `HasMore` info.
         Req.Limit = 0;
       } else {
         // Query index only for the remaining size.
         Req.Limit = Limit - Results.References.size();
       }
     }
     Results.HasMore |= Index->refs(Req, [&](const Ref &R) {
-      auto LSPLoc = toLSPLocation(R.Location, *MainFilePath);
+      auto LSPLoc = toLSPLocation(R.Location, MainFilePath);
       // Avoid indexed results for the main file - the AST is authoritative.
       if (!LSPLoc ||
-          (!AllowMainFileSymbols && LSPLoc->uri.file() == *MainFilePath))
+          (!AllowMainFileSymbols && LSPLoc->uri.file() == MainFilePath))
         return;
       ReferencesResult::Reference Result;
       Result.Loc = std::move(*LSPLoc);
       if (AllowAttributes) {
         if ((R.Kind & RefKind::Declaration) == RefKind::Declaration)
           Result.Attributes |= ReferencesResult::Declaration;
         // FIXME: our index should definitely store def | decl separately!
         if ((R.Kind & RefKind::Definition) == RefKind::Definition)
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
   if (R.Attributes & ReferencesResult::Definition)
     OS << " [def]";
   if (R.Attributes & ReferencesResult::Override)
     OS << " [override]";
   return OS;
 }
 
 template <typename HierarchyItem>
-static llvm::Optional<HierarchyItem> declToHierarchyItem(const NamedDecl &ND) {
+static llvm::Optional<HierarchyItem>
+declToHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
   ASTContext &Ctx = ND.getASTContext();
   auto &SM = Ctx.getSourceManager();
   SourceLocation NameLoc = nameLocation(ND, Ctx.getSourceManager());
   SourceLocation BeginLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getBeginLoc()));
   SourceLocation EndLoc = SM.getSpellingLoc(SM.getFileLoc(ND.getEndLoc()));
   const auto DeclRange =
       toHalfOpenFileRange(SM, Ctx.getLangOpts(), {BeginLoc, EndLoc});
   if (!DeclRange)
     return llvm::None;
   auto FilePath =
       getCanonicalPath(SM.getFileEntryForID(SM.getFileID(NameLoc)), SM);
-  auto TUPath = getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-  if (!FilePath || !TUPath)
+  if (!FilePath)
     return llvm::None; // Not useful without a uri.
 
   Position NameBegin = sourceLocToPosition(SM, NameLoc);
   Position NameEnd = sourceLocToPosition(
       SM, Lexer::getLocForEndOfToken(NameLoc, 0, SM, Ctx.getLangOpts()));
 
   index::SymbolInfo SymInfo = index::getSymbolInfo(&ND);
   // FIXME: This is not classifying constructors, destructors and operators
   // correctly.
   SymbolKind SK = indexSymbolKindToSymbolKind(SymInfo.Kind);
 
   HierarchyItem HI;
   HI.name = printName(Ctx, ND);
   HI.kind = SK;
   HI.range = Range{sourceLocToPosition(SM, DeclRange->getBegin()),
                    sourceLocToPosition(SM, DeclRange->getEnd())};
   HI.selectionRange = Range{NameBegin, NameEnd};
   if (!HI.range.contains(HI.selectionRange)) {
     // 'selectionRange' must be contained in 'range', so in cases where clang
     // reports unrelated ranges we need to reconcile somehow.
     HI.range = HI.selectionRange;
   }
 
-  HI.uri = URIForFile::canonicalize(*FilePath, *TUPath);
+  HI.uri = URIForFile::canonicalize(*FilePath, TUPath);
 
   // Compute the SymbolID and store it in the 'data' field.
   // This allows typeHierarchy/resolve to be used to
   // resolve children of items returned in a previous request
   // for parents.
   if (auto ID = getSymbolID(&ND))
     HI.data = ID.str();
 
   return HI;
 }
 
 static llvm::Optional<TypeHierarchyItem>
-declToTypeHierarchyItem(const NamedDecl &ND) {
-  auto Result = declToHierarchyItem<TypeHierarchyItem>(ND);
+declToTypeHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
+  auto Result = declToHierarchyItem<TypeHierarchyItem>(ND, TUPath);
   if (Result)
     Result->deprecated = ND.isDeprecated();
   return Result;
 }
 
 static llvm::Optional<CallHierarchyItem>
-declToCallHierarchyItem(const NamedDecl &ND) {
-  auto Result = declToHierarchyItem<CallHierarchyItem>(ND);
+declToCallHierarchyItem(const NamedDecl &ND, llvm::StringRef TUPath) {
+  auto Result = declToHierarchyItem<CallHierarchyItem>(ND, TUPath);
   if (Result && ND.isDeprecated())
     Result->tags.push_back(SymbolTag::Deprecated);
   return Result;
 }
 
 template <typename HierarchyItem>
 static llvm::Optional<HierarchyItem> symbolToHierarchyItem(const Symbol &S,
                                                            PathRef TUPath) {
if (Optional<TypeHierarchyItem> ChildSym =
       }
       SubTypes.emplace_back(std::move(*ChildSym));
     }
   });
 }
 
 using RecursionProtectionSet = llvm::SmallSet<const CXXRecordDecl *, 4>;
 
-static void fillSuperTypes(const CXXRecordDecl &CXXRD, ASTContext &ASTCtx,
+static void fillSuperTypes(const CXXRecordDecl &CXXRD, llvm::StringRef TUPath,
                            std::vector<TypeHierarchyItem> &SuperTypes,
                            RecursionProtectionSet &RPSet) {
   // typeParents() will replace dependent template specializations
   // with their class template, so to avoid infinite recursion for
   // certain types of hierarchies, keep the templates encountered
   // along the parent chain in a set, and stop the recursion if one
   // starts to repeat.
   auto *Pattern = CXXRD.getDescribedTemplate() ? &CXXRD : nullptr;
   if (Pattern) {
     if (!RPSet.insert(Pattern).second) {
       return;
     }
   }
 
   for (const CXXRecordDecl *ParentDecl : typeParents(&CXXRD)) {
     if (Optional<TypeHierarchyItem> ParentSym =
-            declToTypeHierarchyItem(*ParentDecl)) {
+            declToTypeHierarchyItem(*ParentDecl, TUPath)) {
       ParentSym->parents.emplace();
-      fillSuperTypes(*ParentDecl, ASTCtx, *ParentSym->parents, RPSet);
+      fillSuperTypes(*ParentDecl, TUPath, *ParentSym->parents, RPSet);
       SuperTypes.emplace_back(std::move(*ParentSym));
     }
   }
 
   if (Pattern) {
     RPSet.erase(Pattern);
   }
 }
getTypeHierarchy(ParsedAST &AST, Position Pos, int ResolveLevels,
   // otherwise the type hierarchy item would misleadingly contain the
   // specialization parameters, while the children would involve classes
   // that derive from other specializations of the template.
   if (WantChildren) {
     if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CXXRD))
       CXXRD = CTSD->getTemplateInstantiationPattern();
   }
 
-  Optional<TypeHierarchyItem> Result = declToTypeHierarchyItem(*CXXRD);
+  Optional<TypeHierarchyItem> Result =
+      declToTypeHierarchyItem(*CXXRD, AST.tuPath());
   if (!Result)
     return Result;
 
   if (WantParents) {
     Result->parents.emplace();
 
     RecursionProtectionSet RPSet;
-    fillSuperTypes(*CXXRD, AST.getASTContext(), *Result->parents, RPSet);
+    fillSuperTypes(*CXXRD, AST.tuPath(), *Result->parents, RPSet);
   }
 
   if (WantChildren && ResolveLevels > 0) {
     Result->children.emplace();
 
     if (Index) {
       if (auto ID = getSymbolID(CXXRD))
         fillSubTypes(ID, *Result->children, Index, ResolveLevels, TUPath);
elog("prepareCallHierarchy failed to convert position to source location: "
          Loc.takeError());
     return Result;
   }
   for (const NamedDecl *Decl : getDeclAtPosition(AST, *Loc, {})) {
     if (!(isa<DeclContext>(Decl) &&
           cast<DeclContext>(Decl)->isFunctionOrMethod()) &&
         Decl->getKind() != Decl::Kind::FunctionTemplate)
       continue;
-    if (auto CHI = declToCallHierarchyItem(*Decl))
+    if (auto CHI = declToCallHierarchyItem(*Decl, AST.tuPath()))
       Result.emplace_back(std::move(*CHI));
   }
   return Result;
 }
 
 std::vector<CallHierarchyIncomingCall>
 incomingCalls(const CallHierarchyItem &Item, const SymbolIndex *Index) {
   std::vector<CallHierarchyIncomingCall> Results;

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

bool prepare(const Selection &Sel) override {
     // Note that we don't check whether an implementation file exists or not in
     // the prepare, since performing disk IO on each prepare request might be
     // expensive.
     return true;
   }
 
   Expected<Effect> apply(const Selection &Sel) override {
     const SourceManager &SM = Sel.AST->getSourceManager();
-    auto MainFileName =
-        getCanonicalPath(SM.getFileEntryForID(SM.getMainFileID()), SM);
-    if (!MainFileName)
-      return error("Couldn't get absolute path for main file.");
-
-    auto CCFile = getSourceFile(*MainFileName, Sel);
+    auto CCFile = getSourceFile(Sel.AST->tuPath(), Sel);
 
     if (!CCFile)
       return error("Couldn't find a suitable implementation file.");
     assert(Sel.FS && "FS Must be set in apply");
     auto Buffer = Sel.FS->getBufferForFile(*CCFile);
     // FIXME: Maybe we should consider creating the implementation file if it
     // doesn't exist?
     if (!Buffer)