use std::collections::HashMap;
use std::path::{Path, PathBuf};
use cpp_parser::{CppSyntaxKind, CppSyntaxNode, SourceRange};
use crate::index::project::{Callee, callee_of_a_call};
use crate::sema::call_syntax::{arguments_of, parameter_list_of, parameter_names_from_text};
use crate::sema::scopes::parameters_of;
use crate::{FileView, Known, ProjectIndex};
use cpp_parser::CppAstNode;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParameterHint {
pub offset: usize,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TypeHint {
pub offset: usize,
pub label: String,
pub kind: TypeHintKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TypeHintKind {
Auto,
StructuredBinding,
DeducedReturn,
LambdaParameter,
}
pub fn type_hints<F, G>(
view: &FileView,
range: SourceRange,
mut type_at: F,
mut returns_at: G,
) -> Vec<TypeHint>
where
F: FnMut(usize) -> Option<String>,
G: FnMut(usize) -> Option<String>,
{
let mut hints: Vec<TypeHint> = Vec::new();
for node in view.root.descendants() {
let kind = CppSyntaxKind::from(node.kind());
match kind {
CppSyntaxKind::InitDeclarator => {
if node.descendants().any(|child| {
CppSyntaxKind::from(child.kind()) == CppSyntaxKind::StructuredBinding
}) {
continue;
}
if !contains(range, node.text_range().start().into())
|| !writes_auto_in_the_declaration(&node)
{
continue;
}
let Some(name) = the_name_of_a_declarator(&node) else {
continue;
};
let at = usize::from(name.text_range().end());
if !contains(range, at) {
continue;
}
if let Some(label) = type_at(usize::from(name.text_range().start()))
&& is_a_type_spelling(&label)
{
hints.push(TypeHint {
offset: at,
label,
kind: TypeHintKind::Auto,
});
}
}
CppSyntaxKind::StructuredBinding => {
if !contains(range, node.text_range().start().into()) {
continue;
}
for name in node.children() {
if CppSyntaxKind::from(name.kind()) != CppSyntaxKind::NameExpr {
continue;
}
let at = usize::from(name.text_range().end());
if !contains(range, at) {
continue;
}
if let Some(label) = type_at(usize::from(name.text_range().start()))
&& is_a_type_spelling(&label)
{
hints.push(TypeHint {
offset: at,
label,
kind: TypeHintKind::StructuredBinding,
});
}
}
}
CppSyntaxKind::LambdaExpr => {
if !contains(range, node.text_range().start().into()) {
continue;
}
let Some(body) = node
.children()
.find(|child| CppSyntaxKind::from(child.kind()) == CppSyntaxKind::CompoundStat)
else {
continue;
};
let written = node.text().to_string();
let before_the_body = written
.find(&body.text().to_string())
.map(|at| &written[..at])
.unwrap_or("");
if before_the_body.contains("->") {
continue;
}
let at = usize::from(body.text_range().start());
if !contains(range, at) {
continue;
}
if let Some(label) = crate::sema::declarations::a_lambdas_return_type(&node, &[])
&& is_a_type_spelling(&label)
{
hints.push(TypeHint {
offset: at,
label,
kind: TypeHintKind::DeducedReturn,
});
}
}
CppSyntaxKind::Declaration | CppSyntaxKind::FunctionDef => {
if !contains(range, node.text_range().start().into()) {
continue;
}
let Some(declarator) = node.children().find(|child| {
matches!(
CppSyntaxKind::from(child.kind()),
CppSyntaxKind::Declarator | CppSyntaxKind::InitDeclarator
)
}) else {
continue;
};
let Some(list) = declarator.descendants().find(|child| {
CppSyntaxKind::from(child.kind()) == CppSyntaxKind::ParameterList
}) else {
continue;
};
if !writes_auto_in_the_declaration(&node) {
continue;
}
let at = usize::from(list.text_range().end());
if !contains(range, at) {
continue;
}
let Some(name) = the_name_of_a_declarator(&node) else {
continue;
};
if let Some(label) = returns_at(usize::from(name.text_range().start()))
&& is_a_type_spelling(&label)
{
hints.push(TypeHint {
offset: at,
label,
kind: TypeHintKind::DeducedReturn,
});
}
}
_ => {}
}
}
hints
}
fn writes_auto_in_the_declaration(node: &CppSyntaxNode) -> bool {
let own = node
.children()
.find(|child| CppSyntaxKind::from(child.kind()) == CppSyntaxKind::DeclSpecifierSeq);
let enclosing = node.ancestors().take(4).find_map(|ancestor| {
ancestor
.children()
.find(|child| CppSyntaxKind::from(child.kind()) == CppSyntaxKind::DeclSpecifierSeq)
});
own.or(enclosing).into_iter().any(|specifiers| {
specifiers.descendants().any(|child| {
let kind = CppSyntaxKind::from(child.kind());
kind == CppSyntaxKind::AutoType
|| (kind == CppSyntaxKind::BuiltinType && child.text().to_string().trim() == "auto")
})
})
}
fn the_name_of_a_declarator(node: &CppSyntaxNode) -> Option<CppSyntaxNode> {
let name = node
.descendants()
.find(|child| CppSyntaxKind::from(child.kind()) == CppSyntaxKind::NameExpr)?;
if name.text().to_string().trim().is_empty() {
return None;
}
Some(name)
}
fn is_a_type_spelling(label: &str) -> bool {
let label = label.trim();
!label.is_empty() && label != "auto" && !label.contains("auto")
}
pub fn parameter_hints<F>(
index: &ProjectIndex,
view: &FileView,
range: SourceRange,
mut view_of: F,
) -> Vec<ParameterHint>
where
F: FnMut(&Path) -> Option<FileView>,
{
let mut hints = Vec::new();
let mut declaring: HashMap<PathBuf, FileView> = HashMap::new();
for call in call_expressions(&view.root, range) {
let Some(arguments) = arguments_of(&call) else {
continue;
};
let asked_about = arguments
.iter()
.any(|argument| contains(range, argument.text_range().start().into()));
if !asked_about {
continue;
}
let trace = crate::probes::inlay();
if trace {
eprintln!(
"[inlay] resolving {}",
call.text()
.to_string()
.lines()
.next()
.unwrap_or_default()
.chars()
.take(60)
.collect::<String>()
);
}
let started = std::time::Instant::now();
let a_variables_call = || {
callable_object_parameter_names(index, view, &call, arguments.len())
.or_else(|| a_lambdas_parameter_names(view, &call, arguments.len()))
};
let names =
constructor_parameter_names(index, view, &call, arguments.len()).or_else(|| {
let Known::Yes(callee) = callee_of_a_call(
&crate::sema::declarations::ShapeTable::new(),
index,
&mut |_: &Path| None,
&view.scopes,
&view.root,
&view.path,
&call,
) else {
return a_variables_call();
};
let resolved = started.elapsed();
let names = parameter_names_for(view, &callee, &mut declaring, &mut view_of)
.or_else(|| {
callee
.parameters
.as_deref()
.and_then(parameter_names_from_text)
});
if trace {
eprintln!(
"[inlay] {} -> {:?}: callee {:?}, names {:?}, {} name(s)",
call.text()
.to_string()
.lines()
.next()
.unwrap_or_default()
.chars()
.take(40)
.collect::<String>(),
callee.file.display(),
resolved,
started.elapsed() - resolved,
names.as_ref().map(Vec::len).unwrap_or(0)
);
}
names.or_else(a_variables_call)
});
let Some(names) = names else {
continue;
};
for (argument, name) in arguments.iter().zip(names.iter()) {
let Some(name) = name else {
continue;
};
if !contains(range, argument.text_range().start().into()) {
continue;
}
if argument.text().to_string().trim() == name {
continue;
}
hints.push(ParameterHint {
offset: argument.text_range().start().into(),
name: name.clone(),
});
}
}
hints
}
fn callable_object_parameter_names(
index: &ProjectIndex,
view: &FileView,
call: &CppSyntaxNode,
passed: usize,
) -> Option<Vec<Option<String>>> {
let callee = call.children().next()?;
let Known::Yes((type_of, _)) = crate::index::project::type_of_expression(
index,
&mut |_: &Path| None,
&view.scopes,
&view.root,
&view.path,
&callee,
0,
) else {
return None;
};
let class = type_of.class_name()?;
let Known::Yes(list) =
crate::index::project::members_of(index, &view.scopes, &view.root, &view.path, class)
else {
return None;
};
let mut best: Option<Vec<Option<String>>> = None;
for member in &list.members {
if member.fact.name != "operator()" {
continue;
}
let Some(text) = member.fact.parameter_list() else {
continue;
};
let Some(names) = parameter_names_from_text(text) else {
continue;
};
if names.len() != passed {
continue;
}
if best.is_none() {
best = Some(names);
}
}
best
}
fn a_lambdas_parameter_names(
view: &FileView,
call: &CppSyntaxNode,
passed: usize,
) -> Option<Vec<Option<String>>> {
let callee = call.children().next()?;
if crate::sema::check::member_access_above(&callee).is_some() {
return None;
}
let at = usize::from(callee.text_range().start());
let Known::Yes(binding) = crate::sema::resolve::definition_at(&view.scopes, &view.root, at)
else {
return None;
};
if binding.kind != crate::BindingKind::Variable {
return None;
}
let declarator = crate::sema::types::declarator_declaring(&view.root, binding.name_range)?;
let holder = declarator.parent()?;
let lambda = cpp_parser::typed_descendants::<cpp_parser::CppLambdaExpr>(&holder).next()?;
let list = lambda.get_params()?;
let text = list.syntax().text().to_string();
let names = parameter_names_from_text(&text)?;
let a_pack = text.contains("...");
if names.len() != passed && !(a_pack && names.len() < passed) {
return None;
}
Some(names)
}
fn constructor_parameter_names(
index: &ProjectIndex,
view: &FileView,
call: &CppSyntaxNode,
passed: usize,
) -> Option<Vec<Option<String>>> {
let callee = call.children().next()?;
let written = callee.text().to_string();
let written = written.trim();
let name = written.rsplit("::").next().unwrap_or(written).trim();
if name.is_empty()
|| !name
.chars()
.all(|character| character.is_alphanumeric() || character == '_')
{
return None;
}
let Known::Yes(found) = index.definitions(name, &view.path) else {
return None;
};
let mut best: Option<Vec<Option<String>>> = None;
for declaration in &found.found {
let fact = &declaration.fact;
if fact.kind != crate::DeclKind::Function || fact.name != name {
continue;
}
let Some(scope) = fact.scope.as_deref() else {
continue;
};
if scope.rsplit("::").next().map(str::trim) != Some(name) {
continue;
}
let Some(list) = fact.parameter_list() else {
continue;
};
let Some(names) = parameter_names_from_text(list) else {
continue;
};
if names.len() < passed {
continue;
}
if best.as_ref().is_none_or(|known| names.len() < known.len()) {
best = Some(names);
}
}
best
}
fn parameter_names_for<F>(
view: &FileView,
callee: &Callee,
declaring: &mut HashMap<PathBuf, FileView>,
view_of: &mut F,
) -> Option<Vec<Option<String>>>
where
F: FnMut(&Path) -> Option<FileView>,
{
let declared_in = if callee.file == view.path {
view
} else {
if !declaring.contains_key(&callee.file) {
declaring.insert(callee.file.clone(), view_of(&callee.file)?);
}
declaring.get(&callee.file).expect("just inserted")
};
let list = parameter_list_of(declared_in, callee.name_offset)?;
let names: Vec<Option<String>> = parameters_of(&list)
.into_iter()
.map(|(_, declared)| declared.map(|(name, _)| name.text()))
.collect();
(!names.is_empty()).then_some(names)
}
fn call_expressions(root: &CppSyntaxNode, range: SourceRange) -> Vec<CppSyntaxNode> {
root.descendants()
.filter(|node| CppSyntaxKind::from(node.kind()) == CppSyntaxKind::CallExpr)
.filter(|node| contains(range, node.text_range().start().into()))
.collect()
}
fn contains(range: SourceRange, offset: usize) -> bool {
offset >= range.start_offset && offset <= range.end_offset()
}
pub fn lambda_parameter_hints<H>(
view: &FileView,
range: SourceRange,
mut deduce: H,
) -> Vec<TypeHint>
where
H: FnMut(&CppSyntaxNode) -> Option<String>,
{
let mut hints = Vec::new();
for node in view.root.descendants() {
if CppSyntaxKind::from(node.kind()) != CppSyntaxKind::LambdaExpr
|| !contains(range, node.text_range().start().into())
{
continue;
}
let Some(list) = node.descendants().find_map(|child| {
use cpp_parser::CppAstNode as _;
cpp_parser::CppParamList::cast(child)
}) else {
continue;
};
for parameter in list.get_params() {
if !parameter.is_auto() {
continue;
}
let Some(name) = cpp_parser::CppAstNode::syntax(¶meter)
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.filter(|token| {
cpp_parser::CppTokenKind::from(token.kind())
== cpp_parser::CppTokenKind::Identifier
})
.last()
else {
continue;
};
let at = usize::from(name.text_range().end());
if !contains(range, at) {
continue;
}
if let Some(label) = deduce(cpp_parser::CppAstNode::syntax(¶meter))
&& is_a_type_spelling(&label)
{
hints.push(TypeHint {
offset: at,
label,
kind: TypeHintKind::LambdaParameter,
});
}
}
}
hints
}