llvm/clang-tools-extra/clangd/Quality.cpp

//===--- Quality.cpp ---------------------------------------------*- C++-*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "Quality.h"
#include "AST.h"
#include "ASTSignals.h"
#include "FileDistance.h"
#include "SourceCode.h"
#include "index/Symbol.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DeclVisitor.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Sema/CodeCompleteConsumer.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cmath>
#include <optional>

namespace clang {
namespace clangd {

static bool hasDeclInMainFile(const Decl &D) { … }

static bool hasUsingDeclInMainFile(const CodeCompletionResult &R) { … }

static SymbolQualitySignals::SymbolCategory categorize(const NamedDecl &ND) { … }

static SymbolQualitySignals::SymbolCategory
categorize(const CodeCompletionResult &R) { … }

static SymbolQualitySignals::SymbolCategory
categorize(const index::SymbolInfo &D) { … }

static bool isInstanceMember(const NamedDecl *ND) { … }

static bool isInstanceMember(const index::SymbolInfo &D) { … }

void SymbolQualitySignals::merge(const CodeCompletionResult &SemaCCResult) { … }

void SymbolQualitySignals::merge(const Symbol &IndexResult) { … }

float SymbolQualitySignals::evaluateHeuristics() const { … }

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                              const SymbolQualitySignals &S) { … }

static SymbolRelevanceSignals::AccessibleScope
computeScope(const NamedDecl *D) { … }

void SymbolRelevanceSignals::merge(const Symbol &IndexResult) { … }

void SymbolRelevanceSignals::computeASTSignals(
    const CodeCompletionResult &SemaResult) { … }

void SymbolRelevanceSignals::merge(const CodeCompletionResult &SemaCCResult) { … }

static float fileProximityScore(unsigned FileDistance) { … }

static float scopeProximityScore(unsigned ScopeDistance) { … }

static std::optional<llvm::StringRef>
wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords) { … }

SymbolRelevanceSignals::DerivedSignals
SymbolRelevanceSignals::calculateDerivedSignals() const { … }

float SymbolRelevanceSignals::evaluateHeuristics() const { … }

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                              const SymbolRelevanceSignals &S) { … }

float evaluateSymbolAndRelevance(float SymbolQuality, float SymbolRelevance) { … }

// Produces an integer that sorts in the same order as F.
// That is: a < b <==> encodeFloat(a) < encodeFloat(b).
static uint32_t encodeFloat(float F) { … }

std::string sortText(float Score, llvm::StringRef Name) { … }

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                              const SignatureQualitySignals &S) { … }

} // namespace clangd
} // namespace clang