CbC/CbC_llvm: clang-tools-extra/clangd/CodeComplete.cpp comparison

comparison clang-tools-extra/clangd/CodeComplete.cpp @ 221:79ff65ed7e25

LLVM12 Original

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 15 Jun 2021 19:15:29 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:42394fc6a535
+:79ff65ed7e25
 #include "index/Index.h"
 #include "index/Symbol.h"
 #include "index/SymbolOrigin.h"
 #include "support/Logger.h"
 #include "support/Threading.h"
+#include "support/ThreadsafeFS.h"
 #include "support/Trace.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/ExternalPreprocessorSource.h"
+#include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <algorithm>
 #include <iterator>
+#include <limits>
 // We log detailed candidate here if you run with -debug-only=codecomplete.
 #define DEBUG_TYPE "CodeComplete"
 namespace clang {
 const RawIdentifier *IdentifierResult = nullptr;
 llvm::SmallVector<llvm::StringRef, 1> RankedIncludeHeaders;
 // Returns a token identifying the overload set this is part of.
 // 0 indicates it's not part of any overload set.
-size_t overloadSet(const CodeCompleteOptions &Opts) const {
+size_t overloadSet(const CodeCompleteOptions &Opts, llvm::StringRef FileName,
+IncludeInserter *Inserter) const {
 if (!Opts.BundleOverloads.getValueOr(false))
 return 0;
+// Depending on the index implementation, we can see different header
+// strings (literal or URI) mapping to the same file. We still want to
+// bundle those, so we must resolve the header to be included here.
+std::string HeaderForHash;
+if (Inserter) {
+if (auto Header = headerToInsertIfAllowed(Opts)) {
+if (auto HeaderFile = toHeaderFile(*Header, FileName)) {
+if (auto Spelled =
+Inserter->calculateIncludePath(*HeaderFile, FileName))
+HeaderForHash = *Spelled;
+} else {
+vlog("Code completion header path manipulation failed {0}",
+HeaderFile.takeError());
+}
+}
+}
 llvm::SmallString<256> Scratch;
 if (IndexResult) {
 switch (IndexResult->SymInfo.Kind) {
 case index::SymbolKind::ClassMethod:
 case index::SymbolKind::InstanceMethod:
 case index::SymbolKind::Function:
 // We can't group overloads together that need different #includes.
 // This could break #include insertion.
 return llvm::hash_combine(
 (IndexResult->Scope + IndexResult->Name).toStringRef(Scratch),
-headerToInsertIfAllowed(Opts).getValueOr(""));
+HeaderForHash);
 default:
 return 0;
 }
 }
 if (SemaResult) {
 return 0;
 {
 llvm::raw_svector_ostream OS(Scratch);
 D->printQualifiedName(OS);
 }
-return llvm::hash_combine(Scratch,
+return llvm::hash_combine(Scratch, HeaderForHash);
-headerToInsertIfAllowed(Opts).getValueOr(""));
 }
 assert(IdentifierResult);
 return 0;
 }
 CodeCompletionString *SemaCCS,
 llvm::ArrayRef<std::string> QueryScopes,
 const IncludeInserter &Includes,
 llvm::StringRef FileName,
 CodeCompletionContext::Kind ContextKind,
-const CodeCompleteOptions &Opts, bool GenerateSnippets)
+const CodeCompleteOptions &Opts,
-: ASTCtx(ASTCtx), ExtractDocumentation(Opts.IncludeComments),
+bool IsUsingDeclaration, tok::TokenKind NextTokenKind)
+: ASTCtx(ASTCtx),
 EnableFunctionArgSnippets(Opts.EnableFunctionArgSnippets),
-GenerateSnippets(GenerateSnippets) {
+IsUsingDeclaration(IsUsingDeclaration), NextTokenKind(NextTokenKind) {
 add(C, SemaCCS);
 if (C.SemaResult) {
 assert(ASTCtx);
 Completion.Origin |= SymbolOrigin::AST;
 Completion.Name = std::string(llvm::StringRef(SemaCCS->getTypedText()));
 auto ResolvedInserted = toHeaderFile(Header, FileName);
 if (!ResolvedInserted)
 return ResolvedInserted.takeError();
 auto Spelled = Includes.calculateIncludePath(*ResolvedInserted, FileName);
 if (!Spelled)
-return llvm::createStringError(llvm::inconvertibleErrorCode(),
+return error("Header not on include path");
-"Header not on include path");
 return std::make_pair(
 std::move(*Spelled),
 Includes.shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
 };
 bool ShouldInsert = C.headerToInsertIfAllowed(Opts).hasValue();
 } else if (C.IndexResult) {
 S.Signature = std::string(C.IndexResult->Signature);
 S.SnippetSuffix = std::string(C.IndexResult->CompletionSnippetSuffix);
 S.ReturnType = std::string(C.IndexResult->ReturnType);
 }
-if (ExtractDocumentation && !Completion.Documentation) {
+if (!Completion.Documentation) {
 auto SetDoc = [&](llvm::StringRef Doc) {
 if (!Doc.empty()) {
 Completion.Documentation.emplace();
 parseDocumentation(Doc, *Completion.Documentation);
 }
 return *RT;
 return "";
 }
 std::string summarizeSnippet() const {
-if (!GenerateSnippets)
+if (IsUsingDeclaration)
 return "";
 auto *Snippet = onlyValue<&BundledEntry::SnippetSuffix>();
 if (!Snippet)
 // All bundles are function calls.
 // FIXME(ibiryukov): sometimes add template arguments to a snippet, e.g.
 // we need to complete 'forward<$1>($0)'.
 return "($0)";
+// Suppress function argument snippets cursor is followed by left
+// parenthesis (and potentially arguments) or if there are potentially
+// template arguments. There are cases where it would be wrong (e.g. next
+// '<' token is a comparison rather than template argument list start) but
+// it is less common and suppressing snippet provides better UX.
+if (Completion.Kind == CompletionItemKind::Function ||
+Completion.Kind == CompletionItemKind::Method ||
+Completion.Kind == CompletionItemKind::Constructor) {
+// If there is a potential template argument list, drop snippet and just
+// complete symbol name. Ideally, this could generate an edit that would
+// paste function arguments after template argument list but it would be
+// complicated. Example:
+//
+// fu^<int> -> function<int>
+if (NextTokenKind == tok::less && Snippet->front() == '<')
+return "";
+// Potentially followed by argument list.
+if (NextTokenKind == tok::l_paren) {
+// If snippet contains template arguments we will emit them and drop
+// function arguments. Example:
+//
+// fu^(42) -> function<int>(42);
+if (Snippet->front() == '<') {
+// Find matching '>'. Snippet->find('>') will not work in cases like
+// template <typename T=std::vector<int>>. Hence, iterate through
+// the snippet until the angle bracket balance reaches zero.
+int Balance = 0;
+size_t I = 0;
+do {
+if (Snippet->at(I) == '>')
+--Balance;
+else if (Snippet->at(I) == '<')
+++Balance;
+++I;
+} while (Balance > 0);
+return Snippet->substr(0, I);
+}
+return "";
+}
+}
 if (EnableFunctionArgSnippets)
 return *Snippet;
 // Replace argument snippets with a simplified pattern.
 if (Snippet->empty())
 // ASTCtx can be nullptr if not run with sema.
 ASTContext *ASTCtx;
 CodeCompletion Completion;
 llvm::SmallVector<BundledEntry, 1> Bundled;
-bool ExtractDocumentation;
 bool EnableFunctionArgSnippets;
-/// When false, no snippets are generated argument lists.
+// No snippets will be generated for using declarations and when the function
-bool GenerateSnippets;
+// arguments are already present.
+bool IsUsingDeclaration;
+tok::TokenKind NextTokenKind;
 };
 // Determine the symbol ID for a Sema code completion result, if possible.
-llvm::Optional<SymbolID> getSymbolID(const CodeCompletionResult &R,
+SymbolID getSymbolID(const CodeCompletionResult &R, const SourceManager &SM) {
-const SourceManager &SM) {
 switch (R.Kind) {
 case CodeCompletionResult::RK_Declaration:
 case CodeCompletionResult::RK_Pattern: {
 // Computing USR caches linkage, which may change after code completion.
 if (hasUnstableLinkage(R.Declaration))
-return llvm::None;
+return {};
 return clang::clangd::getSymbolID(R.Declaration);
 }
 case CodeCompletionResult::RK_Macro:
 return clang::clangd::getSymbolID(R.Macro->getName(), R.MacroDefInfo, SM);
 case CodeCompletionResult::RK_Keyword:
-return None;
+return {};
 }
 llvm_unreachable("unknown CodeCompletionResult kind");
 }
 // Scopes of the partial identifier we're trying to complete.
 if (R->isInjectedClassName())
 return true;
 return false;
 }
-// Some member calls are blacklisted because they're so rarely useful.
+// Some member calls are excluded because they're so rarely useful.
-static bool isBlacklistedMember(const NamedDecl &D) {
+static bool isExcludedMember(const NamedDecl &D) {
 // Destructor completion is rarely useful, and works inconsistently.
 // (s.^ completes ~string, but s.~st^ is an error).
 if (D.getKind() == Decl::CXXDestructor)
 return true;
 // Injected name may be useful for A::foo(), but who writes A::A::foo()?
 (Result.Availability == CXAvailability_NotAvailable ||
 Result.Availability == CXAvailability_NotAccessible))
 continue;
 if (Result.Declaration &&
 !Context.getBaseType().isNull() // is this a member-access context?
-&& isBlacklistedMember(*Result.Declaration))
+&& isExcludedMember(*Result.Declaration))
 continue;
 // Skip injected class name when no class scope is not explicitly set.
 // E.g. show injected A::A in `using A::A^` but not in "A^".
 if (Result.Declaration && !Context.getCXXScopeSpecifier().hasValue() &&
 isInjectedClass(*Result.Declaration))
 CodeCompletionTUInfo CCTUInfo;
 llvm::unique_function<void()> ResultsCallback;
 };
 struct ScoredSignature {
-// When set, requires documentation to be requested from the index with this
+// When not null, requires documentation to be requested from the index with
-// ID.
+// this ID.
-llvm::Optional<SymbolID> IDForDoc;
+SymbolID IDForDoc;
 SignatureInformation Signature;
 SignatureQualitySignals Quality;
 };
 class SignatureHelpCollector final : public CodeCompleteConsumer {
 if (Index) {
 LookupRequest IndexRequest;
 for (const auto &S : ScoredSignatures) {
 if (!S.IDForDoc)
 continue;
-IndexRequest.IDs.insert(*S.IDForDoc);
+IndexRequest.IDs.insert(S.IDForDoc);
 }
 Index->lookup(IndexRequest, [&](const Symbol &S) {
 if (!S.Documentation.empty())
 FetchedDocs[S.ID] = std::string(S.Documentation);
 });
 return L.Signature.label < R.Signature.label;
 });
 for (auto &SS : ScoredSignatures) {
 auto IndexDocIt =
-SS.IDForDoc ? FetchedDocs.find(*SS.IDForDoc) : FetchedDocs.end();
+SS.IDForDoc ? FetchedDocs.find(SS.IDForDoc) : FetchedDocs.end();
 if (IndexDocIt != FetchedDocs.end())
 SS.Signature.documentation = IndexDocIt->second;
 SigHelp.signatures.push_back(std::move(SS.Signature));
 }
 const SymbolIndex *Index;
 }; // SignatureHelpCollector
 struct SemaCompleteInput {
 PathRef FileName;
-const tooling::CompileCommand &Command;
+size_t Offset;
 const PreambleData &Preamble;
-const PreamblePatch &Patch;
+const llvm::Optional<PreamblePatch> Patch;
-llvm::StringRef Contents;
+const ParseInputs &ParseInput;
-size_t Offset;
-llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS;
 };
 void loadMainFilePreambleMacros(const Preprocessor &PP,
 const PreambleData &Preamble) {
 // The ExternalPreprocessorSource has our macros, if we know where to look.
 // We can read all the macros using PreambleMacros->ReadDefinedMacros(),
 // but this includes transitively included files, so may deserialize a lot.
 ExternalPreprocessorSource *PreambleMacros = PP.getExternalSource();
 // As we have the names of the macros, we can look up their IdentifierInfo
 // and then use this to load just the macros we want.
+const auto &ITable = PP.getIdentifierTable();
 IdentifierInfoLookup *PreambleIdentifiers =
-PP.getIdentifierTable().getExternalIdentifierLookup();
+ITable.getExternalIdentifierLookup();
 if (!PreambleIdentifiers || !PreambleMacros)
 return;
-for (const auto &MacroName : Preamble.Macros.Names)
+for (const auto &MacroName : Preamble.Macros.Names) {
+if (ITable.find(MacroName.getKey()) != ITable.end())
+continue;
 if (auto *II = PreambleIdentifiers->get(MacroName.getKey()))
 if (II->isOutOfDate())
 PreambleMacros->updateOutOfDateIdentifier(*II);
+}
 }
 // Invokes Sema code completion on a file.
 // If \p Includes is set, it will be updated based on the compiler invocation.
 bool semaCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
 const clang::CodeCompleteOptions &Options,
 const SemaCompleteInput &Input,
 IncludeStructure *Includes = nullptr) {
 trace::Span Tracer("Sema completion");
-llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = Input.VFS;
-if (Input.Preamble.StatCache)
-VFS = Input.Preamble.StatCache->getConsumingFS(std::move(VFS));
-ParseInputs ParseInput;
-ParseInput.CompileCommand = Input.Command;
-ParseInput.FS = VFS;
-ParseInput.Contents = std::string(Input.Contents);
-// FIXME: setup the recoveryAST and recoveryASTType in ParseInput properly.
 IgnoreDiagnostics IgnoreDiags;
-auto CI = buildCompilerInvocation(ParseInput, IgnoreDiags);
+auto CI = buildCompilerInvocation(Input.ParseInput, IgnoreDiags);
 if (!CI) {
 elog("Couldn't create CompilerInvocation");
 return false;
 }
 auto &FrontendOpts = CI->getFrontendOpts();
 // Setup code completion.
 FrontendOpts.CodeCompleteOpts = Options;
 FrontendOpts.CodeCompletionAt.FileName = std::string(Input.FileName);
 std::tie(FrontendOpts.CodeCompletionAt.Line,
 FrontendOpts.CodeCompletionAt.Column) =
-offsetToClangLineColumn(Input.Contents, Input.Offset);
+offsetToClangLineColumn(Input.ParseInput.Contents, Input.Offset);
 std::unique_ptr<llvm::MemoryBuffer> ContentsBuffer =
-llvm::MemoryBuffer::getMemBufferCopy(Input.Contents, Input.FileName);
+llvm::MemoryBuffer::getMemBuffer(Input.ParseInput.Contents,
+Input.FileName);
 // The diagnostic options must be set before creating a CompilerInstance.
 CI->getDiagnosticOpts().IgnoreWarnings = true;
 // We reuse the preamble whether it's valid or not. This is a
 // correctness/performance tradeoff: building without a preamble is slow, and
 // completion is latency-sensitive.
 // However, if we're completing *inside* the preamble section of the draft,
 // overriding the preamble will break sema completion. Fortunately we can just
 // skip all includes in this case; these completions are really simple.
 PreambleBounds PreambleRegion =
-ComputePreambleBounds(*CI->getLangOpts(), ContentsBuffer.get(), 0);
+ComputePreambleBounds(*CI->getLangOpts(), *ContentsBuffer, 0);
-bool CompletingInPreamble = PreambleRegion.Size > Input.Offset;
+bool CompletingInPreamble = Input.Offset < PreambleRegion.Size ||
-Input.Patch.apply(*CI);
+(!PreambleRegion.PreambleEndsAtStartOfLine &&
+Input.Offset == PreambleRegion.Size);
+if (Input.Patch)
+Input.Patch->apply(*CI);
 // NOTE: we must call BeginSourceFile after prepareCompilerInstance. Otherwise
 // the remapped buffers do not get freed.
+llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS =
+Input.ParseInput.TFS->view(Input.ParseInput.CompileCommand.Directory);
+if (Input.Preamble.StatCache)
+VFS = Input.Preamble.StatCache->getConsumingFS(std::move(VFS));
 auto Clang = prepareCompilerInstance(
 std::move(CI), !CompletingInPreamble ? &Input.Preamble.Preamble : nullptr,
 std::move(ContentsBuffer), std::move(VFS), IgnoreDiags);
 Clang->getPreprocessorOpts().SingleFileParseMode = CompletingInPreamble;
 Clang->setCodeCompletionConsumer(Consumer.release());
 // Sema takes ownership of Recorder. Recorder is valid until Sema cleanup.
 CompletionRecorder *Recorder = nullptr;
 CodeCompletionContext::Kind CCContextKind = CodeCompletionContext::CCC_Other;
 bool IsUsingDeclaration = false;
+// The snippets will not be generated if the token following completion
+// location is an opening parenthesis (tok::l_paren) because this would add
+// extra parenthesis.
+tok::TokenKind NextTokenKind = tok::eof;
 // Counters for logging.
 int NSema = 0, NIndex = 0, NSemaAndIndex = 0, NIdent = 0;
 bool Incomplete = false; // Would more be available with a higher limit?
 CompletionPrefix HeuristicPrefix;
 llvm::Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.
 : FileName(FileName), Includes(Includes), SpecFuzzyFind(SpecFuzzyFind),
 Opts(Opts) {}
 CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {
 trace::Span Tracer("CodeCompleteFlow");
-HeuristicPrefix =
+HeuristicPrefix = guessCompletionPrefix(SemaCCInput.ParseInput.Contents,
-guessCompletionPrefix(SemaCCInput.Contents, SemaCCInput.Offset);
+SemaCCInput.Offset);
-populateContextWords(SemaCCInput.Contents);
+populateContextWords(SemaCCInput.ParseInput.Contents);
 if (Opts.Index && SpecFuzzyFind && SpecFuzzyFind->CachedReq.hasValue()) {
 assert(!SpecFuzzyFind->Result.valid());
 SpecReq = speculativeFuzzyFindRequestForCompletion(
 *SpecFuzzyFind->CachedReq, HeuristicPrefix);
 SpecFuzzyFind->Result = startAsyncFuzzyFind(*Opts.Index, *SpecReq);
 CodeCompleteResult Output;
 auto RecorderOwner = std::make_unique<CompletionRecorder>(Opts, [&]() {
 assert(Recorder && "Recorder is not set");
 CCContextKind = Recorder->CCContext.getKind();
 IsUsingDeclaration = Recorder->CCContext.isUsingDeclaration();
-auto Style = getFormatStyleForFile(
+auto Style = getFormatStyleForFile(SemaCCInput.FileName,
-SemaCCInput.FileName, SemaCCInput.Contents, SemaCCInput.VFS.get());
+SemaCCInput.ParseInput.Contents,
+*SemaCCInput.ParseInput.TFS);
+const auto NextToken = Lexer::findNextToken(
+Recorder->CCSema->getPreprocessor().getCodeCompletionLoc(),
+Recorder->CCSema->getSourceManager(), Recorder->CCSema->LangOpts);
+if (NextToken)
+NextTokenKind = NextToken->getKind();
 // If preprocessor was run, inclusions from preprocessor callback should
 // already be added to Includes.
 Inserter.emplace(
-SemaCCInput.FileName, SemaCCInput.Contents, Style,
+SemaCCInput.FileName, SemaCCInput.ParseInput.Contents, Style,
-SemaCCInput.Command.Directory,
+SemaCCInput.ParseInput.CompileCommand.Directory,
 &Recorder->CCSema->getPreprocessor().getHeaderSearchInfo());
 for (const auto &Inc : Includes.MainFileIncludes)
 Inserter->addExisting(Inc);
 // Most of the cost of file proximity is in initializing the FileDistance
 assert(!Opts.Limit || Output.Completions.size() <= Opts.Limit);
 // We don't assert that isIncomplete means we hit a limit.
 // Indexes may choose to impose their own limits even if we don't have one.
 }
-CodeCompleteResult
+CodeCompleteResult runWithoutSema(llvm::StringRef Content, size_t Offset,
-runWithoutSema(llvm::StringRef Content, size_t Offset,
+const ThreadsafeFS &TFS) && {
-llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) && {
 trace::Span Tracer("CodeCompleteWithoutSema");
 // Fill in fields normally set by runWithSema()
 HeuristicPrefix = guessCompletionPrefix(Content, Offset);
 populateContextWords(Content);
 CCContextKind = CodeCompletionContext::CCC_Recovery;
 llvm::StringMap<SourceParams> ProxSources;
 ProxSources[FileName].Cost = 0;
 FileProximity.emplace(ProxSources);
-auto Style = getFormatStyleForFile(FileName, Content, VFS.get());
+auto Style = getFormatStyleForFile(FileName, Content, TFS);
 // This will only insert verbatim headers.
 Inserter.emplace(FileName, Content, Style,
 /*BuildDir=*/"", /*HeaderSearchInfo=*/nullptr);
 auto Identifiers = collectIdentifiers(Content, Style);
 C.Name = Recorder->getName(*SemaResult);
 } else {
 assert(IdentifierResult);
 C.Name = IdentifierResult->Name;
 }
-if (auto OverloadSet = C.overloadSet(Opts)) {
+if (auto OverloadSet = C.overloadSet(
+Opts, FileName, Inserter ? Inserter.getPointer() : nullptr)) {
 auto Ret = BundleLookup.try_emplace(OverloadSet, Bundles.size());
 if (Ret.second)
 Bundles.emplace_back();
 Bundles[Ret.first->second].push_back(std::move(C));
 } else {
 llvm::DenseSet<const Symbol *> UsedIndexResults;
 auto CorrespondingIndexResult =
 [&](const CodeCompletionResult &SemaResult) -> const Symbol * {
 if (auto SymID =
 getSymbolID(SemaResult, Recorder->CCSema->getSourceManager())) {
-auto I = IndexResults.find(*SymID);
+auto I = IndexResults.find(SymID);
 if (I != IndexResults.end()) {
 UsedIndexResults.insert(&*I);
 return &*I;
 }
 }
 return std::move(Top).items();
 }
 llvm::Optional<float> fuzzyScore(const CompletionCandidate &C) {
 // Macros can be very spammy, so we only support prefix completion.
-// We won't end up with underfull index results, as macros are sema-only.
+if (((C.SemaResult &&
-if (C.SemaResult && C.SemaResult->Kind == CodeCompletionResult::RK_Macro &&
+C.SemaResult->Kind == CodeCompletionResult::RK_Macro) ||
+(C.IndexResult &&
+C.IndexResult->SymInfo.Kind == index::SymbolKind::Macro)) &&
 !C.Name.startswith_lower(Filter->pattern()))
 return None;
 return Filter->match(C.Name);
+}
+CodeCompletion::Scores
+evaluateCompletion(const SymbolQualitySignals &Quality,
+const SymbolRelevanceSignals &Relevance) {
+using RM = CodeCompleteOptions::CodeCompletionRankingModel;
+CodeCompletion::Scores Scores;
+switch (Opts.RankingModel) {
+case RM::Heuristics:
+Scores.Quality = Quality.evaluateHeuristics();
+Scores.Relevance = Relevance.evaluateHeuristics();
+Scores.Total =
+evaluateSymbolAndRelevance(Scores.Quality, Scores.Relevance);
+// NameMatch is in fact a multiplier on total score, so rescoring is
+// sound.
+Scores.ExcludingName =
+Relevance.NameMatch > std::numeric_limits<float>::epsilon()
+? Scores.Total / Relevance.NameMatch
+: Scores.Quality;
+return Scores;
+case RM::DecisionForest:
+DecisionForestScores DFScores = Opts.DecisionForestScorer(
+Quality, Relevance, Opts.DecisionForestBase);
+Scores.ExcludingName = DFScores.ExcludingName;
+Scores.Total = DFScores.Total;
+return Scores;
+}
+llvm_unreachable("Unhandled CodeCompletion ranking model.");
 }
 // Scores a candidate and adds it to the TopN structure.
 void addCandidate(TopN<ScoredBundle, ScoredBundleGreater> &Candidates,
 CompletionCandidate::Bundle Bundle) {
 SymbolQualitySignals Quality;
 SymbolRelevanceSignals Relevance;
 Relevance.Context = CCContextKind;
 Relevance.Name = Bundle.front().Name;
+Relevance.FilterLength = HeuristicPrefix.Name.size();
 Relevance.Query = SymbolRelevanceSignals::CodeComplete;
 Relevance.FileProximityMatch = FileProximity.getPointer();
 if (ScopeProximity)
 Relevance.ScopeProximityMatch = ScopeProximity.getPointer();
 if (PreferredType)
 Relevance.HadContextType = true;
 Relevance.ContextWords = &ContextWords;
+Relevance.MainFileSignals = Opts.MainFileSignals;
 auto &First = Bundle.front();
 if (auto FuzzyScore = fuzzyScore(First))
 Relevance.NameMatch = *FuzzyScore;
 else
 Relevance.Scope = SymbolRelevanceSignals::FileScope;
 Origin |= SymbolOrigin::Identifier;
 }
 }
-CodeCompletion::Scores Scores;
+CodeCompletion::Scores Scores = evaluateCompletion(Quality, Relevance);
-Scores.Quality = Quality.evaluate();
-Scores.Relevance = Relevance.evaluate();
-Scores.Total = evaluateSymbolAndRelevance(Scores.Quality, Scores.Relevance);
-// NameMatch is in fact a multiplier on total score, so rescoring is sound.
-Scores.ExcludingName = Relevance.NameMatch
-? Scores.Total / Relevance.NameMatch
-: Scores.Quality;
 if (Opts.RecordCCResult)
 Opts.RecordCCResult(toCodeCompletion(Bundle), Quality, Relevance,
 Scores.Total);
 dlog("CodeComplete: {0} ({1}) = {2}\n{3}{4}\n", First.Name,
 Item.SemaResult ? Recorder->codeCompletionString(*Item.SemaResult)
 : nullptr;
 if (!Builder)
 Builder.emplace(Recorder ? &Recorder->CCSema->getASTContext() : nullptr,
 Item, SemaCCS, QueryScopes, *Inserter, FileName,
-CCContextKind, Opts,
+CCContextKind, Opts, IsUsingDeclaration, NextTokenKind);
-/*GenerateSnippets=*/!IsUsingDeclaration);
 else
 Builder->add(Item, SemaCCS);
 }
 return Builder->build();
 }
 } // namespace
 clang::CodeCompleteOptions CodeCompleteOptions::getClangCompleteOpts() const {
 clang::CodeCompleteOptions Result;
-Result.IncludeCodePatterns = EnableSnippets && IncludeCodePatterns;
+Result.IncludeCodePatterns = EnableSnippets;
-Result.IncludeMacros = IncludeMacros;
+Result.IncludeMacros = true;
 Result.IncludeGlobals = true;
 // We choose to include full comments and not do doxygen parsing in
 // completion.
 // FIXME: ideally, we should support doxygen in some form, e.g. do markdown
 // formatting of the comments.
 Content.slice(Rest.size(), Result.Name.begin() - Content.begin());
 return Result;
 }
-CodeCompleteResult
+CodeCompleteResult codeComplete(PathRef FileName, Position Pos,
-codeComplete(PathRef FileName, const tooling::CompileCommand &Command,
+const PreambleData *Preamble,
-const PreambleData *Preamble, llvm::StringRef Contents,
+const ParseInputs &ParseInput,
-Position Pos, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+CodeCompleteOptions Opts,
-CodeCompleteOptions Opts, SpeculativeFuzzyFind *SpecFuzzyFind) {
+SpeculativeFuzzyFind *SpecFuzzyFind) {
-auto Offset = positionToOffset(Contents, Pos);
+auto Offset = positionToOffset(ParseInput.Contents, Pos);
 if (!Offset) {
 elog("Code completion position was invalid {0}", Offset.takeError());
 return CodeCompleteResult();
 }
 auto Flow = CodeCompleteFlow(
 FileName, Preamble ? Preamble->Includes : IncludeStructure(),
 SpecFuzzyFind, Opts);
 return (!Preamble || Opts.RunParser == CodeCompleteOptions::NeverParse)
-? std::move(Flow).runWithoutSema(Contents, *Offset, VFS)
+? std::move(Flow).runWithoutSema(ParseInput.Contents, *Offset,
-: std::move(Flow).run({FileName, Command, *Preamble,
+*ParseInput.TFS)
+: std::move(Flow).run({FileName, *Offset, *Preamble,
 // We want to serve code completions with
 // low latency, so don't bother patching.
-PreamblePatch(), Contents, *Offset, VFS});
+/*PreamblePatch=*/llvm::None, ParseInput});
 }
-SignatureHelp signatureHelp(PathRef FileName,
+SignatureHelp signatureHelp(PathRef FileName, Position Pos,
-const tooling::CompileCommand &Command,
 const PreambleData &Preamble,
-llvm::StringRef Contents, Position Pos,
+const ParseInputs &ParseInput) {
-llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+auto Offset = positionToOffset(ParseInput.Contents, Pos);
-const SymbolIndex *Index) {
-auto Offset = positionToOffset(Contents, Pos);
 if (!Offset) {
 elog("Signature help position was invalid {0}", Offset.takeError());
 return SignatureHelp();
 }
 SignatureHelp Result;
 clang::CodeCompleteOptions Options;
 Options.IncludeGlobals = false;
 Options.IncludeMacros = false;
 Options.IncludeCodePatterns = false;
 Options.IncludeBriefComments = false;
-ParseInputs PI;
-PI.CompileCommand = Command;
-PI.Contents = Contents.str();
-PI.FS = std::move(VFS);
-auto PP = PreamblePatch::create(FileName, PI, Preamble);
 semaCodeComplete(
-std::make_unique<SignatureHelpCollector>(Options, Index, Result), Options,
+std::make_unique<SignatureHelpCollector>(Options, ParseInput.Index,
-{FileName, Command, Preamble, PP, Contents, *Offset, std::move(PI.FS)});
+Result),
+Options,
+{FileName, *Offset, Preamble,
+PreamblePatch::create(FileName, ParseInput, Preamble), ParseInput});
 return Result;
 }
 bool isIndexedForCodeCompletion(const NamedDecl &ND, ASTContext &ASTCtx) {
 auto InTopLevelScope = [](const NamedDecl &ND) {

Mercurial > hg > CbC > CbC_llvm

comparison clang-tools-extra/clangd/CodeComplete.cpp @ 221:79ff65ed7e25