Diff 198243

clangd/CodeComplete.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
#include "clang/Lex/PreprocessorOptions.h"		#include "clang/Lex/PreprocessorOptions.h"
#include "clang/Sema/CodeCompleteConsumer.h"		#include "clang/Sema/CodeCompleteConsumer.h"
#include "clang/Sema/DeclSpec.h"		#include "clang/Sema/DeclSpec.h"
#include "clang/Sema/Sema.h"		#include "clang/Sema/Sema.h"
#include "llvm/ADT/ArrayRef.h"		#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/None.h"		#include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h"		#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"		#include "llvm/ADT/SmallVector.h"
		#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"		#include "llvm/ADT/StringRef.h"
		#include "llvm/Support/Debug.h"
#include "llvm/Support/Error.h"		#include "llvm/Support/Error.h"
#include "llvm/Support/Format.h"		#include "llvm/Support/Format.h"
#include "llvm/Support/FormatVariadic.h"		#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/ScopedPrinter.h"		#include "llvm/Support/ScopedPrinter.h"
#include <algorithm>		#include <algorithm>
#include <iterator>		#include <iterator>

// We log detailed candidate here if you run with -debug-only=codecomplete.		// We log detailed candidate here if you run with -debug-only=codecomplete.
▲ Show 20 Lines • Show All 1,144 Lines • ▼ Show 20 Lines	class CodeCompleteFlow {
llvm::Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.		llvm::Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.
Range ReplacedRange;		Range ReplacedRange;
std::vector<std::string> QueryScopes; // Initialized once Sema runs.		std::vector<std::string> QueryScopes; // Initialized once Sema runs.
// Initialized once QueryScopes is initialized, if there are scopes.		// Initialized once QueryScopes is initialized, if there are scopes.
llvm::Optional<ScopeDistance> ScopeProximity;		llvm::Optional<ScopeDistance> ScopeProximity;
llvm::Optional<OpaqueType> PreferredType; // Initialized once Sema runs.		llvm::Optional<OpaqueType> PreferredType; // Initialized once Sema runs.
// Whether to query symbols from any scope. Initialized once Sema runs.		// Whether to query symbols from any scope. Initialized once Sema runs.
bool AllScopes = false;		bool AllScopes = false;
		llvm::StringSet<> ContextWords;
// Include-insertion and proximity scoring rely on the include structure.		// Include-insertion and proximity scoring rely on the include structure.
// This is available after Sema has run.		// This is available after Sema has run.
llvm::Optional<IncludeInserter> Inserter; // Available during runWithSema.		llvm::Optional<IncludeInserter> Inserter; // Available during runWithSema.
llvm::Optional<URIDistance> FileProximity; // Initialized once Sema runs.		llvm::Optional<URIDistance> FileProximity; // Initialized once Sema runs.
/// Speculative request based on the cached request and the filter text before		/// Speculative request based on the cached request and the filter text before
/// the cursor.		/// the cursor.
/// Initialized right before sema run. This is only set if `SpecFuzzyFind` is		/// Initialized right before sema run. This is only set if `SpecFuzzyFind` is
/// set and contains a cached request.		/// set and contains a cached request.
llvm::Optional<FuzzyFindRequest> SpecReq;		llvm::Optional<FuzzyFindRequest> SpecReq;

public:		public:
// A CodeCompleteFlow object is only useful for calling run() exactly once.		// A CodeCompleteFlow object is only useful for calling run() exactly once.
CodeCompleteFlow(PathRef FileName, const IncludeStructure &Includes,		CodeCompleteFlow(PathRef FileName, const IncludeStructure &Includes,
SpeculativeFuzzyFind *SpecFuzzyFind,		SpeculativeFuzzyFind *SpecFuzzyFind,
const CodeCompleteOptions &Opts)		const CodeCompleteOptions &Opts)
: FileName(FileName), Includes(Includes), SpecFuzzyFind(SpecFuzzyFind),		: FileName(FileName), Includes(Includes), SpecFuzzyFind(SpecFuzzyFind),
Opts(Opts) {}		Opts(Opts) {}

CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {		CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {
trace::Span Tracer("CodeCompleteFlow");		trace::Span Tracer("CodeCompleteFlow");
HeuristicPrefix =		HeuristicPrefix =
guessCompletionPrefix(SemaCCInput.Contents, SemaCCInput.Offset);		guessCompletionPrefix(SemaCCInput.Contents, SemaCCInput.Offset);
		populateContextWords(SemaCCInput.Contents);
if (Opts.Index && SpecFuzzyFind && SpecFuzzyFind->CachedReq.hasValue()) {		if (Opts.Index && SpecFuzzyFind && SpecFuzzyFind->CachedReq.hasValue()) {
assert(!SpecFuzzyFind->Result.valid());		assert(!SpecFuzzyFind->Result.valid());
SpecReq = speculativeFuzzyFindRequestForCompletion(		SpecReq = speculativeFuzzyFindRequestForCompletion(
*SpecFuzzyFind->CachedReq, HeuristicPrefix);		*SpecFuzzyFind->CachedReq, HeuristicPrefix);
SpecFuzzyFind->Result = startAsyncFuzzyFind(Opts.Index, SpecReq);		SpecFuzzyFind->Result = startAsyncFuzzyFind(Opts.Index, SpecReq);
}		}

// We run Sema code completion first. It builds an AST and calculates:		// We run Sema code completion first. It builds an AST and calculates:
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines	public:
}		}

CodeCompleteResult		CodeCompleteResult
runWithoutSema(llvm::StringRef Content, size_t Offset,		runWithoutSema(llvm::StringRef Content, size_t Offset,
llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) && {		llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) && {
trace::Span Tracer("CodeCompleteWithoutSema");		trace::Span Tracer("CodeCompleteWithoutSema");
// Fill in fields normally set by runWithSema()		// Fill in fields normally set by runWithSema()
HeuristicPrefix = guessCompletionPrefix(Content, Offset);		HeuristicPrefix = guessCompletionPrefix(Content, Offset);
		populateContextWords(Content);
CCContextKind = CodeCompletionContext::CCC_Recovery;		CCContextKind = CodeCompletionContext::CCC_Recovery;
Filter = FuzzyMatcher(HeuristicPrefix.Name);		Filter = FuzzyMatcher(HeuristicPrefix.Name);
auto Pos = offsetToPosition(Content, Offset);		auto Pos = offsetToPosition(Content, Offset);
ReplacedRange.start = ReplacedRange.end = Pos;		ReplacedRange.start = ReplacedRange.end = Pos;
ReplacedRange.start.character -= HeuristicPrefix.Name.size();		ReplacedRange.start.character -= HeuristicPrefix.Name.size();

llvm::StringMap<SourceParams> ProxSources;		llvm::StringMap<SourceParams> ProxSources;
ProxSources[FileName].Cost = 0;		ProxSources[FileName].Cost = 0;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	runWithoutSema(llvm::StringRef Content, size_t Offset,

CodeCompleteResult Output = toCodeCompleteResult(mergeResults(		CodeCompleteResult Output = toCodeCompleteResult(mergeResults(
/SemaResults=/{}, IndexResults, IdentifierResults));		/SemaResults=/{}, IndexResults, IdentifierResults));
logResults(Output, Tracer);		logResults(Output, Tracer);
return Output;		return Output;
}		}

private:		private:
		void populateContextWords(llvm::StringRef Content) {
		// Take last 3 lines before the completion point.
		unsigned RangeEnd = HeuristicPrefix.Qualifier.begin() - Content.data(),
		RangeBegin = RangeEnd;
		for (size_t I = 0; I < 3 && RangeBegin > 0; ++I) {
		auto PrevNL = Content.rfind('\n', RangeBegin - 1);
		if (PrevNL == StringRef::npos) {
		RangeBegin = 0;
		break;
		}
		RangeBegin = PrevNL + 1;
		}

		ContextWords = collectWords(Content.slice(RangeBegin, RangeEnd));
		dlog("Completion context words: {0}",
		llvm::join(ContextWords.keys(), ", "));
		}

// This is called by run() once Sema code completion is done, but before the		// This is called by run() once Sema code completion is done, but before the
// Sema data structures are torn down. It does all the real work.		// Sema data structures are torn down. It does all the real work.
CodeCompleteResult runWithSema() {		CodeCompleteResult runWithSema() {
const auto &CodeCompletionRange = CharSourceRange::getCharRange(		const auto &CodeCompletionRange = CharSourceRange::getCharRange(
Recorder->CCSema->getPreprocessor().getCodeCompletionTokenRange());		Recorder->CCSema->getPreprocessor().getCodeCompletionTokenRange());
// When we are getting completions with an empty identifier, for example		// When we are getting completions with an empty identifier, for example
// std::vector<int> asdf;		// std::vector<int> asdf;
// asdf.^;		// asdf.^;
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines	private:
}		}

// Scores a candidate and adds it to the TopN structure.		// Scores a candidate and adds it to the TopN structure.
void addCandidate(TopN<ScoredBundle, ScoredBundleGreater> &Candidates,		void addCandidate(TopN<ScoredBundle, ScoredBundleGreater> &Candidates,
CompletionCandidate::Bundle Bundle) {		CompletionCandidate::Bundle Bundle) {
SymbolQualitySignals Quality;		SymbolQualitySignals Quality;
SymbolRelevanceSignals Relevance;		SymbolRelevanceSignals Relevance;
Relevance.Context = CCContextKind;		Relevance.Context = CCContextKind;
		Relevance.Name = Bundle.front().Name;
Relevance.Query = SymbolRelevanceSignals::CodeComplete;		Relevance.Query = SymbolRelevanceSignals::CodeComplete;
Relevance.FileProximityMatch = FileProximity.getPointer();		Relevance.FileProximityMatch = FileProximity.getPointer();
if (ScopeProximity)		if (ScopeProximity)
Relevance.ScopeProximityMatch = ScopeProximity.getPointer();		Relevance.ScopeProximityMatch = ScopeProximity.getPointer();
if (PreferredType)		if (PreferredType)
Relevance.HadContextType = true;		Relevance.HadContextType = true;
		Relevance.ContextWords = &ContextWords;

auto &First = Bundle.front();		auto &First = Bundle.front();
if (auto FuzzyScore = fuzzyScore(First))		if (auto FuzzyScore = fuzzyScore(First))
Relevance.NameMatch = *FuzzyScore;		Relevance.NameMatch = *FuzzyScore;
else		else
return;		return;
SymbolOrigin Origin = SymbolOrigin::Unknown;		SymbolOrigin Origin = SymbolOrigin::Unknown;
bool FromIndex = false;		bool FromIndex = false;
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

clangd/FindSymbols.cpp

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines	Index->fuzzyFind(Req, [HintPath, &Top, &Filter](const Symbol &Sym) {
llvm::StringRef ScopeRef = Scope;		llvm::StringRef ScopeRef = Scope;
ScopeRef.consume_back("::");		ScopeRef.consume_back("::");
SymbolInformation Info = {(Sym.Name + Sym.TemplateSpecializationArgs).str(),		SymbolInformation Info = {(Sym.Name + Sym.TemplateSpecializationArgs).str(),
SK, L, ScopeRef};		SK, L, ScopeRef};

SymbolQualitySignals Quality;		SymbolQualitySignals Quality;
Quality.merge(Sym);		Quality.merge(Sym);
SymbolRelevanceSignals Relevance;		SymbolRelevanceSignals Relevance;
		Relevance.Name = Sym.Name;
Relevance.Query = SymbolRelevanceSignals::Generic;		Relevance.Query = SymbolRelevanceSignals::Generic;
if (auto NameMatch = Filter.match(Sym.Name))		if (auto NameMatch = Filter.match(Sym.Name))
Relevance.NameMatch = *NameMatch;		Relevance.NameMatch = *NameMatch;
else {		else {
log("Workspace symbol: {0} didn't match query {1}", Sym.Name,		log("Workspace symbol: {0} didn't match query {1}", Sym.Name,
Filter.pattern());		Filter.pattern());
return;		return;
}		}
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

clangd/Quality.h

Show All 26 Lines
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_QUALITY_H		#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_QUALITY_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_QUALITY_H		#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_QUALITY_H

#include "ExpectedTypes.h"		#include "ExpectedTypes.h"
#include "FileDistance.h"		#include "FileDistance.h"
#include "clang/Sema/CodeCompleteConsumer.h"		#include "clang/Sema/CodeCompleteConsumer.h"
#include "llvm/ADT/ArrayRef.h"		#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"		#include "llvm/ADT/StringRef.h"
		#include "llvm/ADT/StringSet.h"
#include <algorithm>		#include <algorithm>
#include <functional>		#include <functional>
#include <vector>		#include <vector>

namespace llvm {		namespace llvm {
class raw_ostream;		class raw_ostream;
}		} // namespace llvm

namespace clang {		namespace clang {
class CodeCompletionResult;		class CodeCompletionResult;

namespace clangd {		namespace clangd {

struct Symbol;		struct Symbol;
class URIDistance;		class URIDistance;
Show All 29 Lines	struct SymbolQualitySignals {
// Condense these signals down to a single number, higher is better.		// Condense these signals down to a single number, higher is better.
float evaluate() const;		float evaluate() const;
};		};
llvm::raw_ostream &operator<<(llvm::raw_ostream &,		llvm::raw_ostream &operator<<(llvm::raw_ostream &,
const SymbolQualitySignals &);		const SymbolQualitySignals &);

/// Attributes of a symbol-query pair that affect how much we like it.		/// Attributes of a symbol-query pair that affect how much we like it.
struct SymbolRelevanceSignals {		struct SymbolRelevanceSignals {
		/// The name of the symbol (for ContextWords). Must be explicitly assigned.
		llvm::StringRef Name;
/// 0-1+ fuzzy-match score for unqualified name. Must be explicitly assigned.		/// 0-1+ fuzzy-match score for unqualified name. Must be explicitly assigned.
float NameMatch = 1;		float NameMatch = 1;
		/// Lowercase words relevant to the context (e.g. near the completion point).
		llvm::StringSet<>* ContextWords = nullptr;
bool Forbidden = false; // Unavailable (e.g const) or inaccessible (private).		bool Forbidden = false; // Unavailable (e.g const) or inaccessible (private).
/// Whether fixits needs to be applied for that completion or not.		/// Whether fixits needs to be applied for that completion or not.
bool NeedsFixIts = false;		bool NeedsFixIts = false;
bool InBaseClass = false; // A member from base class of the accessed class.		bool InBaseClass = false; // A member from base class of the accessed class.

URIDistance *FileProximityMatch = nullptr;		URIDistance *FileProximityMatch = nullptr;
/// These are used to calculate proximity between the index symbol and the		/// These are used to calculate proximity between the index symbol and the
/// query.		/// query.
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

clangd/Quality.cpp

Show First 20 Lines • Show All 330 Lines • ▼ Show 20 Lines	static float scopeBoost(ScopeDistance &Distance,
if (!SymbolScope)		if (!SymbolScope)
return 1;		return 1;
auto D = Distance.distance(*SymbolScope);		auto D = Distance.distance(*SymbolScope);
if (D == FileDistance::Unreachable)		if (D == FileDistance::Unreachable)
return 0.6f;		return 0.6f;
return std::max(0.65, 2.0 * std::pow(0.6, D / 2.0));		return std::max(0.65, 2.0 * std::pow(0.6, D / 2.0));
}		}

		static llvm::Optional<llvm::StringRef>
		wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords) {
		if (ContextWords)
		for (const auto& Word : ContextWords->keys())
		if (Name.contains_lower(Word))
		return Word;
		return llvm::None;
		}

float SymbolRelevanceSignals::evaluate() const {		float SymbolRelevanceSignals::evaluate() const {
float Score = 1;		float Score = 1;

if (Forbidden)		if (Forbidden)
return 0;		return 0;

Score *= NameMatch;		Score *= NameMatch;

// File proximity scores are [0,1] and we translate them into a multiplier in		// File proximity scores are [0,1] and we translate them into a multiplier in
// the range from 1 to 3.		// the range from 1 to 3.
Score = 1 + 2 std::max(uriProximity(SymbolURI, FileProximityMatch).first,		Score = 1 + 2 std::max(uriProximity(SymbolURI, FileProximityMatch).first,
SemaFileProximityScore);		SemaFileProximityScore);

if (ScopeProximityMatch)		if (ScopeProximityMatch)
// Use a constant scope boost for sema results, as scopes of sema results		// Use a constant scope boost for sema results, as scopes of sema results
// can be tricky (e.g. class/function scope). Set to the max boost as we		// can be tricky (e.g. class/function scope). Set to the max boost as we
// don't load top-level symbols from the preamble and sema results are		// don't load top-level symbols from the preamble and sema results are
// always in the accessible scope.		// always in the accessible scope.
Score *=		Score *=
SemaSaysInScope ? 2.0 : scopeBoost(*ScopeProximityMatch, SymbolScope);		SemaSaysInScope ? 2.0 : scopeBoost(*ScopeProximityMatch, SymbolScope);

		if (wordMatching(Name, ContextWords))
		Score *= 1.5;

// Symbols like local variables may only be referenced within their scope.		// Symbols like local variables may only be referenced within their scope.
// Conversely if we're in that scope, it's likely we'll reference them.		// Conversely if we're in that scope, it's likely we'll reference them.
if (Query == CodeComplete) {		if (Query == CodeComplete) {
// The narrower the scope where a symbol is visible, the more likely it is		// The narrower the scope where a symbol is visible, the more likely it is
// to be relevant when it is available.		// to be relevant when it is available.
switch (Scope) {		switch (Scope) {
case GlobalScope:		case GlobalScope:
break;		break;
Show All 40 Lines	if (NeedsFixIts)
Score *= 0.5f;		Score *= 0.5f;

return Score;		return Score;
}		}

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,		llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const SymbolRelevanceSignals &S) {		const SymbolRelevanceSignals &S) {
OS << llvm::formatv("=== Symbol relevance: {0}\n", S.evaluate());		OS << llvm::formatv("=== Symbol relevance: {0}\n", S.evaluate());
		OS << llvm::formatv("\tName: {0}\n", S.Name);
OS << llvm::formatv("\tName match: {0}\n", S.NameMatch);		OS << llvm::formatv("\tName match: {0}\n", S.NameMatch);
		if (S.ContextWords)
		OS << llvm::formatv(
		"\tMatching context word: {0}\n",
		wordMatching(S.Name, S.ContextWords).getValueOr("<none>"));
OS << llvm::formatv("\tForbidden: {0}\n", S.Forbidden);		OS << llvm::formatv("\tForbidden: {0}\n", S.Forbidden);
OS << llvm::formatv("\tNeedsFixIts: {0}\n", S.NeedsFixIts);		OS << llvm::formatv("\tNeedsFixIts: {0}\n", S.NeedsFixIts);
OS << llvm::formatv("\tIsInstanceMember: {0}\n", S.IsInstanceMember);		OS << llvm::formatv("\tIsInstanceMember: {0}\n", S.IsInstanceMember);
OS << llvm::formatv("\tContext: {0}\n", getCompletionKindString(S.Context));		OS << llvm::formatv("\tContext: {0}\n", getCompletionKindString(S.Context));
OS << llvm::formatv("\tQuery type: {0}\n", static_cast<int>(S.Query));		OS << llvm::formatv("\tQuery type: {0}\n", static_cast<int>(S.Query));
OS << llvm::formatv("\tScope: {0}\n", static_cast<int>(S.Scope));		OS << llvm::formatv("\tScope: {0}\n", static_cast<int>(S.Scope));

OS << llvm::formatv("\tSymbol URI: {0}\n", S.SymbolURI);		OS << llvm::formatv("\tSymbol URI: {0}\n", S.SymbolURI);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

clangd/SourceCode.h

	Show All 14 Lines
	#include "Context.h"			#include "Context.h"
	#include "Protocol.h"			#include "Protocol.h"
	#include "clang/Basic/Diagnostic.h"			#include "clang/Basic/Diagnostic.h"
	#include "clang/Basic/LangOptions.h"			#include "clang/Basic/LangOptions.h"
	#include "clang/Basic/SourceLocation.h"			#include "clang/Basic/SourceLocation.h"
	#include "clang/Basic/SourceManager.h"			#include "clang/Basic/SourceManager.h"
	#include "clang/Format/Format.h"			#include "clang/Format/Format.h"
	#include "clang/Tooling/Core/Replacement.h"			#include "clang/Tooling/Core/Replacement.h"
				#include "llvm/ADT/StringSet.h"
	#include "llvm/ADT/StringRef.h"			#include "llvm/ADT/StringRef.h"
	#include "llvm/Support/SHA1.h"			#include "llvm/Support/SHA1.h"

	namespace clang {			namespace clang {
	class SourceManager;			class SourceManager;

	namespace clangd {			namespace clangd {

	▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines
	llvm::Expected<tooling::Replacements>			llvm::Expected<tooling::Replacements>
	cleanupAndFormat(StringRef Code, const tooling::Replacements &Replaces,			cleanupAndFormat(StringRef Code, const tooling::Replacements &Replaces,
	const format::FormatStyle &Style);			const format::FormatStyle &Style);

	/// Collects identifiers with counts in the source code.			/// Collects identifiers with counts in the source code.
	llvm::StringMap<unsigned> collectIdentifiers(llvm::StringRef Content,			llvm::StringMap<unsigned> collectIdentifiers(llvm::StringRef Content,
	const format::FormatStyle &Style);			const format::FormatStyle &Style);

				/// Collects words from the source code.
				/// Unlike collectIdentifiers:
				/// - also finds text in comments:
				/// - splits text into words
				/// - drops stopwords like "get" and "for"
				llvm::StringSet<> collectWords(llvm::StringRef Content);

	/// Heuristically determine namespaces visible at a point, without parsing Code.			/// Heuristically determine namespaces visible at a point, without parsing Code.
	/// This considers using-directives and enclosing namespace-declarations that			/// This considers using-directives and enclosing namespace-declarations that
	/// are visible (and not obfuscated) in the file itself (not headers).			/// are visible (and not obfuscated) in the file itself (not headers).
	/// Code should be truncated at the point of interest.			/// Code should be truncated at the point of interest.
	///			///
	/// The returned vector is always non-empty.			/// The returned vector is always non-empty.
	/// - The first element is the namespace that encloses the point: a declaration			/// - The first element is the namespace that encloses the point: a declaration
	/// near the point would be within this namespace.			/// near the point would be within this namespace.
	Show All 18 Lines

clangd/SourceCode.cpp

//===--- SourceCode.h - Manipulating source code as strings ------ C++ --===//		//===--- SourceCode.h - Manipulating source code as strings ------ C++ --===//
//		//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.		// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//
#include "SourceCode.h"		#include "SourceCode.h"

#include "Context.h"		#include "Context.h"
		#include "FuzzyMatch.h"
#include "Logger.h"		#include "Logger.h"
#include "Protocol.h"		#include "Protocol.h"
#include "clang/AST/ASTContext.h"		#include "clang/AST/ASTContext.h"
#include "clang/Basic/SourceManager.h"		#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TokenKinds.h"		#include "clang/Basic/TokenKinds.h"
#include "clang/Format/Format.h"		#include "clang/Format/Format.h"
#include "clang/Lex/Lexer.h"		#include "clang/Lex/Lexer.h"
#include "llvm/ADT/None.h"		#include "llvm/ADT/None.h"
#include "llvm/ADT/StringExtras.h"		#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"		#include "llvm/ADT/StringRef.h"
		#include "llvm/Support/Compiler.h"
#include "llvm/Support/Errc.h"		#include "llvm/Support/Errc.h"
#include "llvm/Support/Error.h"		#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"		#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Path.h"		#include "llvm/Support/Path.h"
#include <algorithm>		#include <algorithm>

namespace clang {		namespace clang {
namespace clangd {		namespace clangd {
▲ Show 20 Lines • Show All 568 Lines • ▼ Show 20 Lines	llvm::sort(Found, [&](const std::string &LHS, const std::string &RHS) {
if (Current == LHS)		if (Current == LHS)
return true;		return true;
return LHS < RHS;		return LHS < RHS;
});		});
Found.erase(std::unique(Found.begin(), Found.end()), Found.end());		Found.erase(std::unique(Found.begin(), Found.end()), Found.end());
return Found;		return Found;
}		}

		llvm::StringSet<> collectWords(llvm::StringRef Content) {
		// We assume short words are not significant.
		// We may want to consider other stopwords, e.g. language keywords.
		// (A very naive implementation showed no benefit, but lexing might do better)
		static constexpr int MinWordLength = 4;

		std::vector<CharRole> Roles(Content.size());
		calculateRoles(Content, Roles);

		llvm::StringSet<> Result;
		llvm::SmallString<256> Word;
		auto Flush = [&] {
		if (Word.size() >= MinWordLength) {
		for (char &C : Word)
		C = llvm::toLower(C);
		Result.insert(Word);
		}
		Word.clear();
		};
		for (unsigned I = 0; I < Content.size(); ++I) {
		switch (Roles[I]) {
		case Head:
		Flush();
		LLVM_FALLTHROUGH;
		case Tail:
		Word.push_back(Content[I]);
		break;
		case Unknown:
		case Separator:
		Flush();
		break;
		}
		}
		Flush();

		return Result;
		}

} // namespace clangd		} // namespace clangd
} // namespace clang		} // namespace clang

clangd/test/completion-auto-trigger.test

	Show All 17 Lines
	# CHECK-NEXT: "items": [			# CHECK-NEXT: "items": [
	# CHECK-NEXT: {			# CHECK-NEXT: {
	# CHECK-NEXT: "detail": "int",			# CHECK-NEXT: "detail": "int",
	# CHECK-NEXT: "filterText": "size",			# CHECK-NEXT: "filterText": "size",
	# CHECK-NEXT: "insertText": "size",			# CHECK-NEXT: "insertText": "size",
	# CHECK-NEXT: "insertTextFormat": 1,			# CHECK-NEXT: "insertTextFormat": 1,
	# CHECK-NEXT: "kind": 5,			# CHECK-NEXT: "kind": 5,
	# CHECK-NEXT: "label": " size",			# CHECK-NEXT: "label": " size",
	# CHECK-NEXT: "sortText": "3eacccccsize",			# CHECK-NEXT: "sortText": "{{.*}}size",
	# CHECK-NEXT: "textEdit": {			# CHECK-NEXT: "textEdit": {
	# CHECK-NEXT: "newText": "size",			# CHECK-NEXT: "newText": "size",
	# CHECK-NEXT: "range": {			# CHECK-NEXT: "range": {
	# CHECK-NEXT: "end": {			# CHECK-NEXT: "end": {
	# CHECK-NEXT: "character": 5,			# CHECK-NEXT: "character": 5,
	# CHECK-NEXT: "line": 3			# CHECK-NEXT: "line": 3
	# CHECK-NEXT: },			# CHECK-NEXT: },
	# CHECK-NEXT: "start": {			# CHECK-NEXT: "start": {
	# CHECK-NEXT: "character": 5,			# CHECK-NEXT: "character": 5,
	# CHECK-NEXT: "line": 3			# CHECK-NEXT: "line": 3
	# CHECK-NEXT: }			# CHECK-NEXT: }
	# CHECK-NEXT: }			# CHECK-NEXT: }
	# CHECK-NEXT: }			# CHECK-NEXT: }
	# CHECK-NEXT: },			# CHECK-NEXT: },
	# CHECK-NEXT: {			# CHECK-NEXT: {
	# CHECK-NEXT: "detail": "int",			# CHECK-NEXT: "detail": "int",
	# CHECK-NEXT: "filterText": "default_capacity",			# CHECK-NEXT: "filterText": "default_capacity",
	# CHECK-NEXT: "insertText": "default_capacity",			# CHECK-NEXT: "insertText": "default_capacity",
	# CHECK-NEXT: "insertTextFormat": 1,			# CHECK-NEXT: "insertTextFormat": 1,
	# CHECK-NEXT: "kind": 10,			# CHECK-NEXT: "kind": 10,
	# CHECK-NEXT: "label": " default_capacity",			# CHECK-NEXT: "label": " default_capacity",
	# CHECK-NEXT: "sortText": "3fd70a3ddefault_capacity",			# CHECK-NEXT: "sortText": "{{.*}}default_capacity",
	# CHECK-NEXT: "textEdit": {			# CHECK-NEXT: "textEdit": {
	# CHECK-NEXT: "newText": "default_capacity",			# CHECK-NEXT: "newText": "default_capacity",
	# CHECK-NEXT: "range": {			# CHECK-NEXT: "range": {
	# CHECK-NEXT: "end": {			# CHECK-NEXT: "end": {
	# CHECK-NEXT: "character": 5,			# CHECK-NEXT: "character": 5,
	# CHECK-NEXT: "line": 3			# CHECK-NEXT: "line": 3
	# CHECK-NEXT: },			# CHECK-NEXT: },
	# CHECK-NEXT: "start": {			# CHECK-NEXT: "start": {
	Show All 22 Lines
	# CHECK-NEXT: "items": [			# CHECK-NEXT: "items": [
	# CHECK-NEXT: {			# CHECK-NEXT: {
	# CHECK-NEXT: "detail": "int",			# CHECK-NEXT: "detail": "int",
	# CHECK-NEXT: "filterText": "ns_member",			# CHECK-NEXT: "filterText": "ns_member",
	# CHECK-NEXT: "insertText": "ns_member",			# CHECK-NEXT: "insertText": "ns_member",
	# CHECK-NEXT: "insertTextFormat": 1,			# CHECK-NEXT: "insertTextFormat": 1,
	# CHECK-NEXT: "kind": 6,			# CHECK-NEXT: "kind": 6,
	# CHECK-NEXT: "label": " ns_member",			# CHECK-NEXT: "label": " ns_member",
	# CHECK-NEXT: "sortText": "3f2cccccns_member",			# CHECK-NEXT: "sortText": "{{.*}}ns_member",
	# CHECK-NEXT: "textEdit": {			# CHECK-NEXT: "textEdit": {
	# CHECK-NEXT: "newText": "ns_member",			# CHECK-NEXT: "newText": "ns_member",
	# CHECK-NEXT: "range": {			# CHECK-NEXT: "range": {
	# CHECK-NEXT: "end": {			# CHECK-NEXT: "end": {
	# CHECK-NEXT: "character": 6,			# CHECK-NEXT: "character": 6,
	# CHECK-NEXT: "line": 6			# CHECK-NEXT: "line": 6
	# CHECK-NEXT: },			# CHECK-NEXT: },
	# CHECK-NEXT: "start": {			# CHECK-NEXT: "start": {
	Show All 11 Lines

clangd/unittests/CodeCompleteTests.cpp

Show All 16 Lines
#include "SyncAPI.h"		#include "SyncAPI.h"
#include "TestFS.h"		#include "TestFS.h"
#include "TestIndex.h"		#include "TestIndex.h"
#include "TestTU.h"		#include "TestTU.h"
#include "index/Index.h"		#include "index/Index.h"
#include "index/MemIndex.h"		#include "index/MemIndex.h"
#include "clang/Sema/CodeCompleteConsumer.h"		#include "clang/Sema/CodeCompleteConsumer.h"
#include "clang/Tooling/CompilationDatabase.h"		#include "clang/Tooling/CompilationDatabase.h"
#include "llvm/Support/Error.h"		#include "llvm/Support/Error.h"
		ilya-biryukovUnsubmitted Done Reply Inline Actions This included was probably added accidentally. Remove? ilya-biryukov: This included was probably added accidentally. Remove?
#include "llvm/Support/Path.h"		#include "llvm/Support/Path.h"
#include "llvm/Testing/Support/Error.h"		#include "llvm/Testing/Support/Error.h"
#include "gmock/gmock.h"		#include "gmock/gmock.h"
		ilya-biryukovUnsubmitted Done Reply Inline Actions This include is redundant, maybe remove it? (added by clangd for sure) ilya-biryukov: This include is redundant, maybe remove it? (added by clangd for sure)
#include "gtest/gtest.h"		#include "gtest/gtest.h"

namespace clang {		namespace clang {
namespace clangd {		namespace clangd {

namespace {		namespace {
using ::llvm::Failed;		using ::llvm::Failed;
using ::testing::AllOf;		using ::testing::AllOf;
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines	TEST(CompletionTest, Limit) {
clangd::CodeCompleteOptions Opts;		clangd::CodeCompleteOptions Opts;
Opts.Limit = 2;		Opts.Limit = 2;
auto Results = completions(R"cpp(		auto Results = completions(R"cpp(
struct ClassWithMembers {		struct ClassWithMembers {
int AAA();		int AAA();
int BBB();		int BBB();
int CCC();		int CCC();
};		};

int main() { ClassWithMembers().^ }		int main() { ClassWithMembers().^ }
)cpp",		)cpp",
/IndexSymbols=/{}, Opts);		/IndexSymbols=/{}, Opts);

EXPECT_TRUE(Results.HasMore);		EXPECT_TRUE(Results.HasMore);
EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB")));		EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB")));
}		}

▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines	TEST(CompletionTest, CompletionOptions) {
// Test with one flag flipped.		// Test with one flag flipped.
for (auto &F : Flags) {		for (auto &F : Flags) {
clangd::CodeCompleteOptions O;		clangd::CodeCompleteOptions O;
O.*F ^= true;		O.*F ^= true;
Test(O);		Test(O);
}		}
}		}

TEST(CompletionTest, Priorities) {		TEST(CompletionTest, Accessible) {
auto Internal = completions(R"cpp(		auto Internal = completions(R"cpp(
class Foo {		class Foo {
public: void pub();		public: void pub();
protected: void prot();		protected: void prot();
private: void priv();		private: void priv();
};		};
void Foo::pub() { this->^ }		void Foo::pub() { this->^ }
)cpp");		)cpp");
EXPECT_THAT(Internal.Completions,		EXPECT_THAT(Internal.Completions,
HasSubsequence(Named("priv"), Named("prot"), Named("pub")));		AllOf(Has("priv"), Has("prot"), Has("pub")));

auto External = completions(R"cpp(		auto External = completions(R"cpp(
class Foo {		class Foo {
public: void pub();		public: void pub();
protected: void prot();		protected: void prot();
private: void priv();		private: void priv();
};		};
void test() {		void test() {
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines	TEST(CompletionTest, ReferencesAffectRanking) {
EXPECT_THAT(Results.Completions,		EXPECT_THAT(Results.Completions,
HasSubsequence(Named("absb"), Named("absl")));		HasSubsequence(Named("absb"), Named("absl")));
Results = completions("int main() { abs^ }",		Results = completions("int main() { abs^ }",
{withReferences(10000, ns("absl")), func("absb")});		{withReferences(10000, ns("absl")), func("absb")});
EXPECT_THAT(Results.Completions,		EXPECT_THAT(Results.Completions,
HasSubsequence(Named("absl"), Named("absb")));		HasSubsequence(Named("absl"), Named("absb")));
}		}

		TEST(CompletionTest, ContextWords) {
		auto Results = completions(R"cpp(
		enum class Color { RED, YELLOW, BLUE };

		// (blank lines so the definition above isn't "context")

		// "It was a yellow car," he said. "Big yellow car, new."
		auto Finish = Color::^
		)cpp");
		// Yellow would normally sort last (alphabetic).
		// But the recent mention shuold bump it up.
		ASSERT_THAT(Results.Completions,
		HasSubsequence(Named("YELLOW"), Named("BLUE")));
		}

TEST(CompletionTest, GlobalQualified) {		TEST(CompletionTest, GlobalQualified) {
auto Results = completions(		auto Results = completions(
R"cpp(		R"cpp(
void f() { ::^ }		void f() { ::^ }
)cpp",		)cpp",
{cls("XYZ")});		{cls("XYZ")});
EXPECT_THAT(Results.Completions,		EXPECT_THAT(Results.Completions,
AllOf(Has("XYZ", CompletionItemKind::Class),		AllOf(Has("XYZ", CompletionItemKind::Class),
▲ Show 20 Lines • Show All 2,020 Lines • Show Last 20 Lines

clangd/unittests/QualityTests.cpp

Show First 20 Lines • Show All 286 Lines • ▼ Show 20 Lines	TEST(QualityTests, SymbolRelevanceSignalsSanity) {
Instance.Context = CodeCompletionContext::CCC_DotMemberAccess;		Instance.Context = CodeCompletionContext::CCC_DotMemberAccess;
EXPECT_LT(Instance.evaluate(), Default.evaluate());		EXPECT_LT(Instance.evaluate(), Default.evaluate());
Instance.IsInstanceMember = true;		Instance.IsInstanceMember = true;
EXPECT_EQ(Instance.evaluate(), Default.evaluate());		EXPECT_EQ(Instance.evaluate(), Default.evaluate());

SymbolRelevanceSignals InBaseClass;		SymbolRelevanceSignals InBaseClass;
InBaseClass.InBaseClass = true;		InBaseClass.InBaseClass = true;
EXPECT_LT(InBaseClass.evaluate(), Default.evaluate());		EXPECT_LT(InBaseClass.evaluate(), Default.evaluate());

		llvm::StringSet<> Words = {"one", "two", "three"};
		SymbolRelevanceSignals WithoutMatchingWord;
		WithoutMatchingWord.ContextWords = &Words;
		WithoutMatchingWord.Name = "four";
		EXPECT_EQ(WithoutMatchingWord.evaluate(), Default.evaluate());
		SymbolRelevanceSignals WithMatchingWord;
		WithMatchingWord.ContextWords = &Words;
		WithMatchingWord.Name = "TheTwoTowers";
		EXPECT_GT(WithMatchingWord.evaluate(), Default.evaluate());
}		}

TEST(QualityTests, ScopeProximity) {		TEST(QualityTests, ScopeProximity) {
SymbolRelevanceSignals Relevance;		SymbolRelevanceSignals Relevance;
ScopeDistance ScopeProximity({"x::y::z::", "x::", "llvm::", ""});		ScopeDistance ScopeProximity({"x::y::z::", "x::", "llvm::", ""});
Relevance.ScopeProximityMatch = &ScopeProximity;		Relevance.ScopeProximityMatch = &ScopeProximity;

Relevance.SymbolScope = "other::";		Relevance.SymbolScope = "other::";
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

clangd/unittests/SourceCodeTests.cpp

Show All 16 Lines
#include "gtest/gtest.h"		#include "gtest/gtest.h"

namespace clang {		namespace clang {
namespace clangd {		namespace clangd {
namespace {		namespace {

using llvm::Failed;		using llvm::Failed;
using llvm::HasValue;		using llvm::HasValue;
		using ::testing::UnorderedElementsAreArray;
		ilya-biryukovUnsubmitted Done Reply Inline Actions NIT: use `::testing` to be consistent with the rest of the code in clangd? ilya-biryukov: NIT: use `::testing` to be consistent with the rest of the code in clangd?

MATCHER_P2(Pos, Line, Col, "") {		MATCHER_P2(Pos, Line, Col, "") {
return arg.line == int(Line) && arg.character == int(Col);		return arg.line == int(Line) && arg.character == int(Col);
}		}

/// A helper to make tests easier to read.		/// A helper to make tests easier to read.
Position position(int line, int character) {		Position position(int line, int character) {
Position Pos;		Position Pos;
▲ Show 20 Lines • Show All 284 Lines • ▼ Show 20 Lines	TEST(SourceCodeTests, CollectIdentifiers) {
EXPECT_EQ(IDs["void"], 1u);		EXPECT_EQ(IDs["void"], 1u);
EXPECT_EQ(IDs["int"], 2u);		EXPECT_EQ(IDs["int"], 2u);
EXPECT_EQ(IDs["xyz"], 2u);		EXPECT_EQ(IDs["xyz"], 2u);
EXPECT_EQ(IDs["abc"], 1u);		EXPECT_EQ(IDs["abc"], 1u);
EXPECT_EQ(IDs["return"], 1u);		EXPECT_EQ(IDs["return"], 1u);
EXPECT_EQ(IDs["foo"], 2u);		EXPECT_EQ(IDs["foo"], 2u);
}		}

		TEST(SourceCodeTests, CollectWords) {
		auto Words = collectWords(R"cpp(
		#define FIZZ_BUZZ
		// this is a comment
		std::string getSomeText() { return "magic word"; }
		)cpp");
		std::set<std::string> ActualWords(Words.keys().begin(), Words.keys().end());
		std::set<std::string> ExpectedWords = {"define", "fizz", "buzz", "this",
		"comment", "string", "some", "text",
		"return", "magic", "word"};
		EXPECT_EQ(ActualWords, ExpectedWords);
		}

TEST(SourceCodeTests, VisibleNamespaces) {		TEST(SourceCodeTests, VisibleNamespaces) {
std::vector<std::pair<const char *, std::vector<std::string>>> Cases = {		std::vector<std::pair<const char *, std::vector<std::string>>> Cases = {
{		{
R"cpp(		R"cpp(
// Using directive resolved against enclosing namespaces.		// Using directive resolved against enclosing namespaces.
using namespace foo;		using namespace foo;
namespace ns {		namespace ns {
using namespace bar;		using namespace bar;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[clangd] Boost code completion results that were named in the last few lines.
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 198243

clangd/CodeComplete.cpp

clangd/FindSymbols.cpp

clangd/Quality.h

clangd/Quality.cpp

clangd/SourceCode.h

clangd/SourceCode.cpp

clangd/test/completion-auto-trigger.test

clangd/unittests/CodeCompleteTests.cpp

clangd/unittests/QualityTests.cpp

clangd/unittests/SourceCodeTests.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[clangd] Boost code completion results that were named in the last few lines.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 198243

clangd/CodeComplete.cpp

clangd/FindSymbols.cpp

clangd/Quality.h

clangd/Quality.cpp

clangd/SourceCode.h

clangd/SourceCode.cpp

clangd/test/completion-auto-trigger.test

clangd/unittests/CodeCompleteTests.cpp

clangd/unittests/QualityTests.cpp

clangd/unittests/SourceCodeTests.cpp

[clangd] Boost code completion results that were named in the last few lines.
ClosedPublic