Prototype for include-fixer workflow in clangd. [NOT FOR REVIEW]

[ioeric]

Include-fixer has been landed in clangd.

clangd/ClangdServer.cpp

 }
 
 void ClangdServer::addDocument(PathRef File, llvm::StringRef Contents,
                                WantDiagnostics WantDiags) {
   // FIXME: some build systems like Bazel will take time to preparing
   // environment to build the file, it would be nice if we could emit a
   // "PreparingBuild" status to inform users, it is non-trivial given the
   // current implementation.
+  log("      AddDocument with Index: {0}", Index);
   WorkScheduler.update(File,
-                       ParseInputs{getCompileCommand(File),
-                                   FSProvider.getFileSystem(), Contents.str()},
+                       ParseInputs(getCompileCommand(File),
+                                   FSProvider.getFileSystem(), Contents.str(),
+                                   Index),
                        WantDiags);
 }
 
 void ClangdServer::removeDocument(PathRef File) { WorkScheduler.remove(File); }
 
 void ClangdServer::codeComplete(PathRef File, Position Pos,
                                 const clangd::CodeCompleteOptions &Opts,
                                 Callback<CodeCompleteResult> CB) {

clangd/ClangdUnit.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDUNIT_H
 
 #include "Diagnostics.h"
 #include "FS.h"
 #include "Function.h"
 #include "Headers.h"
 #include "Path.h"
 #include "Protocol.h"
+#include "index/Index.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/PrecompiledPreamble.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include <memory>
 #include <string>
struct PreambleData {
   IncludeStructure Includes;
   // Cache of FS operations performed when building the preamble.
   // When reusing a preamble, this cache can be consumed to save IO.
   std::unique_ptr<PreambleFileStatusCache> StatCache;
 };
 
 /// Information required to run clang, e.g. to parse AST or do code completion.
 struct ParseInputs {
+  ParseInputs(tooling::CompileCommand CompileCommand,
+              IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
+              std::string Contents, const SymbolIndex *Index = nullptr)
+      : CompileCommand(CompileCommand), FS(std::move(FS)),
+        Contents(std::move(Contents)), Index(Index) {}
+
+  ParseInputs() = default;
+
   tooling::CompileCommand CompileCommand;
   IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS;
   std::string Contents;
+  const SymbolIndex *Index = nullptr;
 };
 
 /// Stores and provides access to parsed AST.
 class ParsedAST {
 public:
   /// Attempts to run Clang and store parsed AST. If \p Preamble is non-null
   /// it is reused during parsing.
   static llvm::Optional<ParsedAST>
   build(std::unique_ptr<clang::CompilerInvocation> CI,
         std::shared_ptr<const PreambleData> Preamble,
         std::unique_ptr<llvm::MemoryBuffer> Buffer,
         std::shared_ptr<PCHContainerOperations> PCHs,
-        IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS);
+        IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+        const SymbolIndex *Index);
 
   ParsedAST(ParsedAST &&Other);
   ParsedAST &operator=(ParsedAST &&Other);
 
   ~ParsedAST();
 
   /// Note that the returned ast will not contain decls from the preamble that
   /// were not deserialized during parsing. Clients should expect only decls

clangd/ClangdUnit.cpp

 //===--- ClangdUnit.cpp ------------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdUnit.h"
 #include "../clang-tidy/ClangTidyDiagnosticConsumer.h"
 #include "../clang-tidy/ClangTidyModuleRegistry.h"
+#include "AST.h"
+#include "ClangdServer.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
+#include "Headers.h"
 #include "Logger.h"
+#include "Protocol.h"
 #include "SourceCode.h"
 #include "Trace.h"
+#include "index/Index.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/AST/DeclarationName.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Index/IndexDataConsumer.h"
 #include "clang/Index/IndexingAction.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
+#include "clang/Sema/DeclSpec.h"
+#include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Serialization/ASTWriter.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <string>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 bool compileCommandsAreEqual(const tooling::CompileCommand &LHS,
                              const tooling::CompileCommand &RHS) {
   // We don't check for Output, it should not matter to clangd.
private:
 
   const IncludeStructure &Includes;
   PPCallbacks *Delegate;
   const SourceManager &SM;
   Preprocessor &PP;
   const LangOptions &LangOpts;
 };
 
+// TODO: merge with the copy in CodeComplete.cpp
+static llvm::Expected<HeaderFile> toHeaderFile(llvm::StringRef Header,
+                                               llvm::StringRef HintPath) {
+  if (isLiteralInclude(Header))
+    return HeaderFile{Header.str(), /*Verbatim=*/true};
+  auto U = URI::parse(Header);
+  if (!U)
+    return U.takeError();
+
+  auto IncludePath = URI::includeSpelling(*U);
+  if (!IncludePath)
+    return IncludePath.takeError();
+  if (!IncludePath->empty())
+    return HeaderFile{std::move(*IncludePath), /*Verbatim=*/true};
+
+  auto Resolved = URI::resolve(*U, HintPath);
+  if (!Resolved)
+    return Resolved.takeError();
+  return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
+}
+
+// TODO: add missing include for incomplete type e.g. only see forward decl.
+// TODO: support the following case when clang-tidy header hasn't been included.
+//    namespace clang {
+//    void f() {
+//      tidy::Check c;
+//      ~~~~
+//      // or
+//      clang::tidy::Check c;
+//             ~~~~
+//    }
+//    }
+//    For both cases, the typo and the diagnostic are both on "tidy". However,
+//    the "typo" (or symbol) we want to fix is "clang::tidy::Check".
+class IncludeFixer : public ExternalSemaSource, public DiagnosticConsumer {
+public:
+  IncludeFixer(llvm::StringRef FileName, CompilerInstance *CI,
+               DiagnosticConsumer *Delegated, const IncludeInserter &Inserter,
+               const SymbolIndex *Index)
+      : FileName(FileName), Compiler(CI), Delegated(Delegated),
+        Inserter(Inserter), Index(Index) {}
+
+  struct TypoRecord {
+    std::string Typo;
+    SourceLocation Loc;
+    Scope *S;
+    std::string SS;
+    bool IsValidSS;
+    DeclContext *MemberContext;
+    int LookupKind;
+  };
+
+  TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, int LookupKind,
+                             Scope *S, CXXScopeSpec *SS,
+                             CorrectionCandidateCallback &CCC,
+                             DeclContext *MemberContext, bool EnteringContext,
+                             const ObjCObjectPointerType *OPT) override {
+    log("IncludeFixer: CorrectTypo \"{0}\"", Typo.getAsString());
+    auto &SemaRef = Compiler->getSema();
+    if (SemaRef.isSFINAEContext())
+      return TypoCorrection();
+    const auto &SM = Compiler->getSourceManager();
+    if (!SM.isWrittenInMainFile(Typo.getLoc()))
+      return clang::TypoCorrection();
+    TypoRecord Record;
+    Record.Typo = Typo.getAsString();
+    Record.Loc = Typo.getBeginLoc();
+    Record.MemberContext = MemberContext;
+    Record.S = S;
+    Record.LookupKind = LookupKind;
+
+    Record.SS = "";
+    Record.IsValidSS = false;
+    if (SS) {
+      if (SS->isNotEmpty()) {
+        if (auto *Nested = SS->getScopeRep()) {
+          if (const auto *NS = Nested->getAsNamespace()) {
+            Record.SS = printNamespaceScope(*NS);
+            Record.IsValidSS = true;
+          }
+        } else {
+          auto QS = Lexer::getSourceText(
+                        CharSourceRange::getCharRange(SS->getRange()), SM,
+                        clang::LangOptions())
+                        .ltrim("::");
+          Record.SS = QS;
+        }
+      }
+    }
+    LastTypo = std::move(Record);
+
+    return TypoCorrection();
+  }
+
+  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
+                        const clang::Diagnostic &Info) override {
+    if (Delegated) {
+      Delegated->HandleDiagnostic(DiagLevel, Info);
+    }
+    log("IncludeFixer::HandleDiagnostic (Index: {0})", Index);
+    if (DiagLevel >= DiagnosticsEngine::Error) {
+      log(">>>>>>>>>>>>>>>>>>>>>>>   LogLevel >= Error!!!! <<<<<<<<<<<<");
+      IgnoreDiagnostics::log(DiagLevel, Info);
+      if (LastTypo) {
+        if (LastTypo->Loc != Info.getLocation())
+          return;
+        if (!Index)
+          return;
+        const auto &SM = Compiler->getSourceManager();
+        auto *S = LastTypo->S;
+        log("========== Last typo ========= ");
+        if (LastTypo->MemberContext)
+          log("    MemberContext: {0}",
+              printNamespaceScope(*LastTypo->MemberContext));
+        log("    TODO: handle typo: \"{0}\" at {1}", LastTypo->Typo,
+            LastTypo->Loc.printToString(SM));
+        log("    CXXScopeSpec: \"{0}\" Valid: {1}", LastTypo->SS,
+            LastTypo->IsValidSS);
+
+        std::vector<std::string> Scopes;
+        if (LastTypo->SS.empty()) {
+          auto &SemaRef = Compiler->getSema();
+          std::vector<DeclContext *> Visited;
+          VisitedContextCollector Collector(&Visited);
+          log("      Collecting contexts with lookup...");
+          if (S)
+            SemaRef.LookupVisibleDecls(
+                S, (Sema::LookupNameKind)LastTypo->LookupKind, Collector,
+                /*IncludeGlobalScope=*/false,
+                /*LoadExternal=*/false);
+          log("          Collected {0} contexts.", Visited.size());
+          Scopes.push_back("");
+          for (const auto *Ctx : Visited) {
+            if (isa<TranslationUnitDecl>(Ctx))
+              log("                     global"); // global namespace
+            else if (isa<NamespaceDecl>(Ctx)) {
+              log("                     {0}", printNamespaceScope(*Ctx));
+              Scopes.push_back(printNamespaceScope(*Ctx));
+            }
+          }
+          } else {
+            Scopes.push_back(LastTypo->SS);
+          }
+          log("         Collected scopes: [{0}]",
+              llvm::join(Scopes.begin(), Scopes.end(), ", "));
+          std::string HeaderToInsert;
+          std::string DeclaringFile;
+          FuzzyFindRequest Req;
+          Req.AnyScope = false;
+          Req.Query = LastTypo->Typo;
+          Req.Scopes = Scopes;
+          Req.RestrictForCodeCompletion = true;
+          log("    ----- Querying index");
+          Index->fuzzyFind(Req, [&](const Symbol &Sym) {
+            if (Sym.Name != Req.Query)
+              return;
+            if (!HeaderToInsert.empty())
+              return;
+            log("                   Symbol {0}{1} matched with {2} includes.",
+                Sym.Scope, Sym.Name, Sym.IncludeHeaders.size());
+            if (!Sym.IncludeHeaders.empty()) {
+              HeaderToInsert = Sym.IncludeHeaders[0].IncludeHeader;
+              DeclaringFile = Sym.CanonicalDeclaration.FileURI;
+            }
+          });
+
+          if (HeaderToInsert.empty())
+            return;
+          log("  ------>>>> Inserting new header: {0}", HeaderToInsert);
+          auto Inserted = [&](llvm::StringRef Header)
+              -> llvm::Expected<std::pair<std::string, bool>> {
+            auto ResolvedDeclaring = toHeaderFile(DeclaringFile, FileName);
+            if (!ResolvedDeclaring)
+              return ResolvedDeclaring.takeError();
+            auto ResolvedInserted = toHeaderFile(Header, FileName);
+            if (!ResolvedInserted)
+              return ResolvedInserted.takeError();
+            return std::make_pair(Inserter.calculateIncludePath(
+                                      *ResolvedDeclaring, *ResolvedInserted),
+                                  Inserter.shouldInsertInclude(
+                                      *ResolvedDeclaring, *ResolvedInserted));
+          };
+          llvm::Optional<TextEdit> Edit;
+          if (auto ToInclude = Inserted(HeaderToInsert)) {
+            CodeCompletion::IncludeCandidate Include;
+            Include.Header = ToInclude->first;
+            HeaderToInsert = ToInclude->first;
+            if (ToInclude->second) {
+              Edit = Inserter.insert(ToInclude->first);
+            }
+          } else
+            log("Failed to generate include insertion edits for adding "
+                "header "
+                "(FileURI='{0}', IncludeHeader='{1}') into {2}",
+                DeclaringFile, HeaderToInsert, FileName);
+
+          if (!Edit)
+            return;
+          Diag D;
+          D.Range = diagnosticRange(Info, LangOptions());
+          llvm::SmallString<64> Message;
+          Info.FormatDiagnostic(Message);
+          D.Message = ("Attempt to fix error: " + Message.str()).str();
+          // D.Message = "Unknown identifier!!!!";
+          D.InsideMainFile = true;
+          D.File = Info.getSourceManager().getFilename(Info.getLocation());
+          D.Severity = DiagLevel;
+          D.Category =
+              DiagnosticIDs::getCategoryNameFromID(
+                  DiagnosticIDs::getCategoryNumberForDiag(Info.getID()))
+                  .str();
+          llvm::SmallVector<TextEdit, 1> Edits;
+          Edits.push_back(std::move(*Edit));
+          D.Fixes.push_back(
+              Fix{"Insert missing include " +
+                      llvm::StringRef(HeaderToInsert).trim('<').trim('>').str(),
+                  std::move(Edits)});
+          log("Added new diagnostics for inserting {0}!!!!", HeaderToInsert);
+          Diags.push_back(std::move(D));
+          LastTypo.reset(); // LastTypo has been handled.
+      }
+    }
+  }
+
+  std::vector<Diag> takeDiags() { return std::move(Diags); }
+
+private:
+  class VisitedContextCollector : public VisibleDeclConsumer {
+    public:
+      VisitedContextCollector(std::vector<DeclContext *> *Visited)
+          : Visited(Visited) {}
+
+      void EnteredContext(DeclContext *Ctx) override {
+        Visited->push_back(Ctx);
+      }
+
+      void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
+                     bool InBaseClass) override {}
+
+    private:
+      std::vector<DeclContext *> *Visited;
+
+  };
+
+  std::string FileName;
+  CompilerInstance *Compiler;
+  DiagnosticConsumer *Delegated;
+  const IncludeInserter &Inserter;
+  const SymbolIndex *Index;
+
+  std::vector<Diag> Diags;
+  llvm::Optional<TypoRecord> LastTypo;
+};
+
 } // namespace
 
 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS) {
   AST.getASTContext().getTranslationUnitDecl()->dump(OS, true);
 }
 
 llvm::Optional<ParsedAST>
 ParsedAST::build(std::unique_ptr<CompilerInvocation> CI,
                  std::shared_ptr<const PreambleData> Preamble,
                  std::unique_ptr<llvm::MemoryBuffer> Buffer,
                  std::shared_ptr<PCHContainerOperations> PCHs,
-                 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
+                 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+                 const SymbolIndex *Index) {
   assert(CI);
   // Command-line parsing sets DisableFree to true by default, but we don't want
   // to leak memory in clangd.
   CI->getFrontendOpts().DisableFree = false;
   const PrecompiledPreamble *PreamblePCH =
       Preamble ? &Preamble->Preamble : nullptr;
 
   StoreDiags ASTDiags;
+  std::string Content = Buffer->getBuffer();
   auto Clang =
       prepareCompilerInstance(std::move(CI), PreamblePCH, std::move(Buffer),
-                              std::move(PCHs), std::move(VFS), ASTDiags);
+                              std::move(PCHs), VFS, ASTDiags);
   if (!Clang)
     return None;
 
   auto Action = llvm::make_unique<ClangdFrontendAction>();
   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
   if (!Action->BeginSourceFile(*Clang, MainInput)) {
     log("BeginSourceFile() failed when building AST for {0}",
         MainInput.getFile());
llvm::Optional<tidy::ClangTidyContext> CTContext;
     CTFactories.createChecks(CTContext.getPointer(), CTChecks);
     for (const auto &Check : CTChecks) {
       // FIXME: the PP callbacks skip the entire preamble.
       // Checks that want to see #includes in the main file do not see them.
       Check->registerPPCallbacks(*Clang);
       Check->registerMatchers(&CTFinder);
     }
   }
+  std::unique_ptr<DiagnosticConsumer> DiagClient;
+  DiagnosticConsumer *DiagClientPtr = nullptr;
+  auto &DiagEng =Clang->getDiagnostics();
+  if (DiagEng.ownsClient()) {
+    DiagClient = DiagEng.takeClient();
+    DiagClientPtr = DiagClient.get();
+  } else {
+    DiagClientPtr = DiagEng.getClient();
+  }
+  auto Style = format::getStyle(format::DefaultFormatStyle, MainInput.getFile(),
+                                format::DefaultFallbackStyle,
+                                Content, VFS.get());
+  if (!Style) {
+    log("getStyle() failed for file {0}: {1}. Fallback is LLVM style.",
+        MainInput.getFile(), Style.takeError());
+    Style = format::getLLVMStyle();
+  }
+  auto CWD = VFS->getCurrentWorkingDirectory();
+  if (auto Err = CWD.getError()) {
+    elog("Failed to get CWD from VFS: {0}", Err.message());
+  }
+  IncludeInserter Inserter(MainInput.getFile(), Content, *Style, CWD.get(),
+                           Clang->getPreprocessor().getHeaderSearchInfo());
+  if (Preamble) {
+    for (const auto &Inc : Preamble->Includes.MainFileIncludes)
+      Inserter.addExisting(Inc);
+  }
+  IntrusiveRefCntPtr<IncludeFixer> FixIncludes(new IncludeFixer(
+      MainInput.getFile(), Clang.get(), DiagClientPtr, Inserter, Index));
+  DiagEng.setErrorLimit(0);
+  Clang->setExternalSemaSource(FixIncludes);
+  DiagEng.setClient(FixIncludes.get(), /*ShouldOwnClient=*/false);
 
   // Copy over the includes from the preamble, then combine with the
   // non-preamble includes below.
   auto Includes = Preamble ? Preamble->Includes : IncludeStructure{};
   // Replay the preamble includes so that clang-tidy checks can see them.
   if (Preamble)
     ReplayPreamble::attach(Includes, *Clang);
   // Important: collectIncludeStructure is registered *after* ReplayPreamble!
   // Otherwise we would collect the replayed includes again...
   // (We can't *just* use the replayed includes, they don't have Resolved path).
   Clang->getPreprocessor().addPPCallbacks(
       collectIncludeStructureCallback(Clang->getSourceManager(), &Includes));
 
   if (!Action->Execute())
     log("Execute() failed when building AST for {0}", MainInput.getFile());
 
   std::vector<Decl *> ParsedDecls = Action->takeTopLevelDecls();
+
   // AST traversals should exclude the preamble, to avoid performance cliffs.
   Clang->getASTContext().setTraversalScope(ParsedDecls);
   {
     // Run the AST-dependent part of the clang-tidy checks.
     // (The preprocessor part ran already, via PPCallbacks).
     trace::Span Tracer("ClangTidyMatch");
     CTFinder.matchAST(Clang->getASTContext());
   }
 
   // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
   // has a longer lifetime.
+  //Clang->getDiagnostics().setClient(FixIncludes.get(), /*ShouldOwnClient=*/false);
   Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
   // CompilerInstance won't run this callback, do it directly.
   ASTDiags.EndSourceFile();
   // XXX: This is messy: clang-tidy checks flush some diagnostics at EOF.
   // However Action->EndSourceFile() would destroy the ASTContext!
   // So just inform the preprocessor of EOF, while keeping everything alive.
   Clang->getPreprocessor().EndSourceFile();
 
   std::vector<Diag> Diags = ASTDiags.take();
   // Add diagnostics from the preamble, if any.
   if (Preamble)
     Diags.insert(Diags.begin(), Preamble->Diags.begin(), Preamble->Diags.end());
+  auto IncludeFixerDiags = FixIncludes->takeDiags();
+  if (!IncludeFixerDiags.empty())
+    Diags.insert(Diags.begin(), IncludeFixerDiags.begin(),
+                 IncludeFixerDiags.end());
   return ParsedAST(std::move(Preamble), std::move(Clang), std::move(Action),
                    std::move(ParsedDecls), std::move(Diags),
                    std::move(Includes));
 }
 
 ParsedAST::ParsedAST(ParsedAST &&Other) = default;
 
 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
if (VFS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
     log("Couldn't set working directory when building the preamble.");
     // We proceed anyway, our lit-tests rely on results for non-existing working
     // dirs.
   }
 
   return ParsedAST::build(llvm::make_unique<CompilerInvocation>(*Invocation),
                           Preamble,
                           llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents),
-                          PCHs, std::move(VFS));
+                          PCHs, std::move(VFS), Inputs.Index);
 }
 
 SourceLocation getBeginningOfIdentifier(ParsedAST &Unit, const Position &Pos,
                                         const FileID FID) {
   const ASTContext &AST = Unit.getASTContext();
   const SourceManager &SourceMgr = AST.getSourceManager();
   auto Offset = positionToOffset(SourceMgr.getBufferData(FID), Pos);
   if (!Offset) {

clangd/Diagnostics.h

 private:
   void flushLastDiag();
 
   std::vector<Diag> Output;
   llvm::Optional<LangOptions> LangOpts;
   llvm::Optional<Diag> LastDiag;
 };
 
+Range diagnosticRange(const clang::Diagnostic &D, const LangOptions &L);
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H

clangd/Diagnostics.cpp

bool locationInRange(SourceLocation L, CharSourceRange R,
                      const SourceManager &M) {
   assert(R.isCharRange());
   if (!R.isValid() || M.getFileID(R.getBegin()) != M.getFileID(R.getEnd()) ||
       M.getFileID(R.getBegin()) != M.getFileID(L))
     return false;
   return L != R.getEnd() && M.isPointWithin(L, R.getBegin(), R.getEnd());
 }
 
-// Clang diags have a location (shown as ^) and 0 or more ranges (~~~~).
-// LSP needs a single range.
-Range diagnosticRange(const clang::Diagnostic &D, const LangOptions &L) {
-  auto &M = D.getSourceManager();
-  auto Loc = M.getFileLoc(D.getLocation());
-  for (const auto &CR : D.getRanges()) {
-    auto R = Lexer::makeFileCharRange(CR, M, L);
-    if (locationInRange(Loc, R, M))
-      return halfOpenToRange(M, R);
-  }
-  llvm::Optional<Range> FallbackRange;
-  // The range may be given as a fixit hint instead.
-  for (const auto &F : D.getFixItHints()) {
-    auto R = Lexer::makeFileCharRange(F.RemoveRange, M, L);
-    if (locationInRange(Loc, R, M))
-      return halfOpenToRange(M, R);
-    // If there's a fixit that performs insertion, it has zero-width. Therefore
-    // it can't contain the location of the diag, but it might be possible that
-    // this should be reported as range. For example missing semicolon.
-    if (R.getBegin() == R.getEnd() && Loc == R.getBegin())
-      FallbackRange = halfOpenToRange(M, R);
-  }
-  if (FallbackRange)
-    return *FallbackRange;
-  // If no suitable range is found, just use the token at the location.
-  auto R = Lexer::makeFileCharRange(CharSourceRange::getTokenRange(Loc), M, L);
-  if (!R.isValid()) // Fall back to location only, let the editor deal with it.
-    R = CharSourceRange::getCharRange(Loc);
-  return halfOpenToRange(M, R);
-}
-
 bool isInsideMainFile(const SourceLocation Loc, const SourceManager &M) {
   return Loc.isValid() && M.isWrittenInMainFile(M.getFileLoc(Loc));
 }
 
 bool isInsideMainFile(const clang::Diagnostic &D) {
   if (!D.hasSourceManager())
     return false;
 
std::string noteMessage(const Diag &Main, const DiagBase &Note) {
   OS << Note.Message;
   OS << "\n\n";
   printDiag(OS, Main);
   OS.flush();
   return capitalize(std::move(Result));
 }
 } // namespace
 
+
+// Clang diags have a location (shown as ^) and 0 or more ranges (~~~~).
+// LSP needs a single range.
+Range diagnosticRange(const clang::Diagnostic &D, const LangOptions &L) {
+  auto &M = D.getSourceManager();
+  auto Loc = M.getFileLoc(D.getLocation());
+  for (const auto &CR : D.getRanges()) {
+    auto R = Lexer::makeFileCharRange(CR, M, L);
+    if (locationInRange(Loc, R, M))
+      return halfOpenToRange(M, R);
+  }
+  llvm::Optional<Range> FallbackRange;
+  // The range may be given as a fixit hint instead.
+  for (const auto &F : D.getFixItHints()) {
+    auto R = Lexer::makeFileCharRange(F.RemoveRange, M, L);
+    if (locationInRange(Loc, R, M))
+      return halfOpenToRange(M, R);
+    // If there's a fixit that performs insertion, it has zero-width. Therefore
+    // it can't contain the location of the diag, but it might be possible that
+    // this should be reported as range. For example missing semicolon.
+    if (R.getBegin() == R.getEnd() && Loc == R.getBegin())
+      FallbackRange = halfOpenToRange(M, R);
+  }
+  if (FallbackRange)
+    return *FallbackRange;
+  // If no suitable range is found, just use the token at the location.
+  auto R = Lexer::makeFileCharRange(CharSourceRange::getTokenRange(Loc), M, L);
+  if (!R.isValid()) // Fall back to location only, let the editor deal with it.
+    R = CharSourceRange::getCharRange(Loc);
+  return halfOpenToRange(M, R);
+}
+
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const DiagBase &D) {
   OS << "[";
   if (!D.InsideMainFile)
     OS << D.File << ":";
   OS << D.Range.start << "-" << D.Range.end << "] ";
 
   return OS << D.Message;
 }

unittests/clangd/CodeCompleteTests.cpp

TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) {
   auto C = Results.Completions;
   EXPECT_THAT(C, ElementsAre(Named("fooey:")));
   EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
   EXPECT_THAT(C, ElementsAre(ReturnType("id")));
   EXPECT_THAT(C, ElementsAre(Signature("(unsigned int)")));
   EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(unsigned int)}")));
 }
 
+TEST(CompletionTest, CorrectTypo) {
+  auto Results = completions(R"cpp(
+    namespace nx {
+    namespace nz {
+    void f() {
+      nx::Clangd x;
+      ::Clangg y;
+      Clangc xx;
+      plus(Clangd, some());
+      ^
+    }
+    }
+    }
+  )cpp",
+                             {cls("nx::Clangd1"), cls("nx::Clangd2")});
+  // Although Clangd1 is from another namespace, Sema tells us it's in-scope and
+  // needs no qualifier.
+  EXPECT_THAT(Results.Completions, UnorderedElementsAre());
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang

unittests/clangd/FileIndexTests.cpp

TEST(FileIndexTest, ReferencesInMainFileWithPreamble) {
   // Prepare preamble.
   auto CI = buildCompilerInvocation(PI);
   auto PreambleData = buildPreamble(
       MainFile, *buildCompilerInvocation(PI), /*OldPreamble=*/nullptr,
       tooling::CompileCommand(), PI, std::make_shared<PCHContainerOperations>(),
       /*StoreInMemory=*/true,
       [&](ASTContext &Ctx, std::shared_ptr<Preprocessor> PP) {});
   // Build AST for main file with preamble.
-  auto AST =
-      ParsedAST::build(createInvocationFromCommandLine(Cmd), PreambleData,
-                       llvm::MemoryBuffer::getMemBufferCopy(Main.code()),
-                       std::make_shared<PCHContainerOperations>(), PI.FS);
+  auto AST = ParsedAST::build(
+      createInvocationFromCommandLine(Cmd), PreambleData,
+      std::make_shared<PCHContainerOperations>(), PI.FS, nullptr);
   ASSERT_TRUE(AST);
   FileIndex Index;
   Index.updateMain(MainFile, *AST);
 
   auto Foo = findSymbol(TestTU::withHeaderCode(Header).headerSymbols(), "Foo");
   RefsRequest Request;
   Request.IDs.insert(Foo.ID);
 
   // Expect to see references in main file, references in headers are excluded
   // because we only index main AST.
   EXPECT_THAT(getRefs(Index, Foo.ID), RefsAre({RefRange(Main.range())}));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

unittests/clangd/TUSchedulerTests.cpp

 
 MATCHER_P2(TUState, State, ActionName, "") {
   return arg.Action.S == State && arg.Action.Name == ActionName;
 }
 
 class TUSchedulerTests : public ::testing::Test {
 protected:
   ParseInputs getInputs(PathRef File, std::string Contents) {
-    return ParseInputs{*CDB.getCompileCommand(File),
-                       buildTestFS(Files, Timestamps), std::move(Contents)};
+    return ParseInputs(*CDB.getCompileCommand(File),
+                       buildTestFS(Files, Timestamps), std::move(Contents));
   }
 
   void updateWithCallback(TUScheduler &S, PathRef File,
                           llvm::StringRef Contents, WantDiagnostics WD,
                           llvm::unique_function<void()> CB) {
     WithContextValue Ctx(llvm::make_scope_exit(std::move(CB)));
     S.update(File, getInputs(File, Contents), WD);
   }