97 lines
3.9 KiB
C++
97 lines
3.9 KiB
C++
#pragma once
|
|
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/TypeLoc.h"
|
|
|
|
namespace clice::ast {
|
|
|
|
/// is this decl a definition?
|
|
bool is_definition(const clang::Decl* decl);
|
|
|
|
/// Check whether the decl is a template. Note that for partial specializations,
|
|
/// we consider it as a template while clang does not.
|
|
bool is_templated(const clang::Decl* decl);
|
|
|
|
/// Return the decl where it is instantiated from. If could be a template decl
|
|
/// or a member of a class template. If the decl is a full specialization, return
|
|
/// itself.
|
|
const clang::NamedDecl* instantiated_from(const clang::NamedDecl* decl);
|
|
|
|
const clang::NamedDecl* normalize(const clang::NamedDecl* decl);
|
|
|
|
/// Get the name of the decl.
|
|
std::string name_of(const clang::NamedDecl* decl);
|
|
|
|
/// To response go-to-type-definition request. Some decls actually have a type
|
|
/// for example the result of `typeof(var)` is the type of `var`. This function
|
|
/// returns the type for the decl if any.
|
|
clang::QualType type_of(const clang::NamedDecl* decl);
|
|
|
|
const clang::NamedDecl* get_decl_for_type(const clang::Type* T);
|
|
|
|
/// Get the underlying decl for a type if any.
|
|
const clang::NamedDecl* decl_of(clang::QualType type);
|
|
|
|
/// Check whether the decl is anonymous.
|
|
bool is_anonymous(const clang::NamedDecl* decl);
|
|
|
|
clang::NestedNameSpecifierLoc get_qualifier_loc(const clang::NamedDecl* decl);
|
|
|
|
auto get_template_specialization_args(const clang::NamedDecl* decl)
|
|
-> std::optional<llvm::ArrayRef<clang::TemplateArgumentLoc>>;
|
|
|
|
std::string print_template_specialization_args(const clang::NamedDecl* decl);
|
|
|
|
std::string print_name(const clang::NamedDecl* decl);
|
|
|
|
clang::TemplateTypeParmTypeLoc get_contained_auto_param_type(clang::TypeLoc TL);
|
|
|
|
clang::NamedDecl* get_only_instantiation(clang::NamedDecl* TemplatedDecl);
|
|
|
|
/// getSimpleName() returns the plain identifier for an entity, if any.
|
|
llvm::StringRef getSimpleName(const clang::DeclarationName& DN);
|
|
llvm::StringRef getSimpleName(const clang::NamedDecl& D);
|
|
llvm::StringRef getSimpleName(clang::QualType T);
|
|
|
|
std::string summarizeExpr(const clang::Expr* E);
|
|
|
|
// Returns the template parameter pack type from an instantiated function
|
|
// template, if it exists, nullptr otherwise.
|
|
const clang::TemplateTypeParmType* getFunctionPackType(const clang::FunctionDecl* Callee);
|
|
|
|
// Returns the template parameter pack type that this parameter was expanded
|
|
// from (if in the Args... or Args&... or Args&&... form), if this is the case,
|
|
// nullptr otherwise.
|
|
const clang::TemplateTypeParmType* getUnderlyingPackType(const clang::ParmVarDecl* Param);
|
|
|
|
// Returns the parameters that are forwarded from the template parameters.
|
|
// For example, `template <typename... Args> void foo(Args... args)` will return
|
|
// the `args` parameters.
|
|
llvm::SmallVector<const clang::ParmVarDecl*>
|
|
resolveForwardingParameters(const clang::FunctionDecl* D, unsigned MaxDepth = 10);
|
|
|
|
// Determines if any intermediate type in desugaring QualType QT is of
|
|
// substituted template parameter type. Ignore pointer or reference wrappers.
|
|
bool isSugaredTemplateParameter(clang::QualType QT);
|
|
|
|
// A simple wrapper for `clang::desugarForDiagnostic` that provides optional
|
|
// semantic.
|
|
std::optional<clang::QualType> desugar(clang::ASTContext& AST, clang::QualType QT);
|
|
|
|
// Apply a series of heuristic methods to determine whether or not a QualType QT
|
|
// is suitable for desugaring (e.g. getting the real name behind the using-alias
|
|
// name). If so, return the desugared type. Otherwise, return the unchanged
|
|
// parameter QT.
|
|
//
|
|
// This could be refined further. See
|
|
// https://github.com/clangd/clangd/issues/1298.
|
|
clang::QualType maybeDesugar(clang::ASTContext& AST, clang::QualType QT);
|
|
|
|
// Given a callee expression `Fn`, if the call is through a function pointer,
|
|
// try to find the declaration of the corresponding function pointer type,
|
|
// so that we can recover argument names from it.
|
|
// FIXME: This function is mostly duplicated in SemaCodeComplete.cpp; unify.
|
|
clang::FunctionProtoTypeLoc getPrototypeLoc(clang::Expr* Fn);
|
|
|
|
} // namespace clice::ast
|