use super::*;
pub(crate) fn declaration_of_expression(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
expression: &cpp_parser::CppSyntaxNode,
) -> Known<NamedDeclaration> {
let offset = end_of_the_written_name(expression);
let written = expression.text().to_string();
let written = written.trim();
let asked = crate::sema::resolve::definition_at(scopes, root, offset);
match asked {
Known::Yes(binding) => Known::Yes(NamedDeclaration::Here(binding)),
Known::Unknown(UnknownReason::NotDeclaredHere(name)) => {
if let Some(member) =
a_member_of_the_enclosing_class(index, scopes, root, path, expression, true)
{
return Known::Yes(NamedDeclaration::Indexed(
member.fact,
member.file,
TypeBindings::default(),
));
}
let mut candidates: Vec<&str> = vec![name.as_ref()];
if let Some(without) = name.strip_prefix("::") {
candidates.push(without);
}
if let Some((_, without_the_prefix)) = name.split_once(' ') {
candidates.push(without_the_prefix.trim());
}
if let Some((first, rest)) = name.split_once("::")
&& written_like_a_macro(first)
{
candidates.push(rest);
}
let mut was_ambiguous = false;
for candidate in candidates {
let found: Option<(crate::DeclFact, PathBuf)> =
match index.definition(candidate, path) {
Known::Yes(found) => Some((found.fact, found.file)),
Known::Unknown(UnknownReason::Ambiguous(_)) => {
was_ambiguous = true;
agreeing_type(index, path, candidate)
}
Known::Unknown(_) | Known::No => None,
};
if let Some((fact, file)) = found {
return Known::Yes(NamedDeclaration::Indexed(
fact,
file,
TypeBindings::default(),
));
}
}
if was_ambiguous {
Known::Unknown(UnknownReason::Ambiguous(Box::from(written)))
} else {
Known::Unknown(UnknownReason::UnknownType(Box::from(written)))
}
}
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
}
}
pub(crate) fn a_function_pointer_returns(a_type: &Type) -> Option<Type> {
let Type::Pointer { to } = a_type else {
return None;
};
match to.as_ref() {
Type::Function { returns, .. } => Some(returns.as_ref().clone()),
_ => None,
}
}
pub(crate) fn a_lambdas_body_the_callee_names(
root: &cpp_parser::CppSyntaxNode,
scopes: &crate::ScopeTree,
callee: &cpp_parser::CppSyntaxNode,
argument_types: &[Type],
) -> Option<String> {
let inside = callee.text_range();
let Known::Yes(binding) =
crate::sema::resolve::definition_at(scopes, root, inside.start().into())
else {
return None;
};
let name = binding.name_range;
let declarator = root.descendants().find(|node| {
let range = node.text_range();
CppSyntaxKind::from(node.kind()) == CppSyntaxKind::InitDeclarator
&& usize::from(range.start()) <= name.start_offset
&& name.end_offset() <= usize::from(range.end())
})?;
let lambda = declarator
.descendants()
.find(|node| CppSyntaxKind::from(node.kind()) == CppSyntaxKind::LambdaExpr)?;
crate::sema::declarations::a_lambdas_return_type(&lambda, argument_types)
}
pub(crate) fn type_of_a_call(
memo: &TypeMemo,
shapes: &crate::sema::declarations::ShapeTable,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
call: &cpp_parser::CppSyntaxNode,
depth: usize,
) -> Known<(Type, PathBuf)> {
let written = call.text().to_string();
let written = written.trim();
let Some(callee) = call.children().next() else {
return Known::Unknown(UnknownReason::UnknownType(Box::from(written)));
};
if let Some(element) =
iterator_element_type(memo, index, declaring, scopes, root, path, &callee)
{
return element;
}
let written_arguments = {
let from_the_callee = written_template_arguments(&callee);
if from_the_callee.is_empty() {
call.children()
.take_while(|child| {
CppSyntaxKind::from(child.kind()) != CppSyntaxKind::ArgumentList
})
.filter_map(|child| {
if CppSyntaxKind::from(child.kind()) == CppSyntaxKind::TemplateArgumentList {
return Some(child);
}
child.descendants().find(|node| {
CppSyntaxKind::from(node.kind()) == CppSyntaxKind::TemplateArgumentList
})
})
.next()
.map(|list| crate::sema::types::read_template_arguments(&list))
.unwrap_or_default()
} else {
from_the_callee
}
};
let argument_types: Vec<Type> = if written_arguments.is_empty() {
crate::sema::call_syntax::arguments_of(call)
.unwrap_or_default()
.iter()
.filter_map(|argument| {
match type_of_expression_memoed(
memo, shapes, index, declaring, scopes, root, path, argument, 0,
) {
Known::Yes((type_of, _)) => Some(type_of),
_ => None,
}
})
.collect()
} else {
Vec::new()
};
if names_the_identity_function(&callee)
&& let Some(type_of) = argument_types.first()
{
return Known::Yes((type_of.clone(), path.to_path_buf()));
}
if let Known::Yes((callee_type, file)) = type_of_expression_memoed(
memo, shapes, index, declaring, scopes, root, path, &callee, 0,
) && let Some(returns) = a_function_pointer_returns(&callee_type)
{
return Known::Yes((returns, file));
}
if let Some(returns) = a_lambdas_body_the_callee_names(root, scopes, &callee, &argument_types) {
return Known::Yes((
crate::sema::types::parse_type_spelling(&returns),
path.to_path_buf(),
));
}
let resolved = declaration_of_a_callee(
memo, shapes, index, declaring, scopes, root, path, &callee, written,
);
let names_a_function = match &resolved {
Known::Yes(named) => named.fact_kind() == crate::DeclKind::Function,
_ => false,
};
if !names_a_function
&& let Known::Yes((callee_type, file)) = type_of_expression_memoed(
memo, shapes, index, declaring, scopes, root, path, &callee, 0,
)
&& matches!(callee_type, Type::Named { .. })
&& let Some(returns) = operator_returns_of_with_arguments(
index,
declaring,
scopes,
root,
path,
&callee_type,
"operator()",
&argument_types,
crate::sema::call_syntax::arguments_of(call).map(|arguments| arguments.len()),
)
{
return Known::Yes((crate::sema::types::parse_type_spelling(&returns), file));
}
if let Some(pointer) = the_factory_the_call_names(&callee)
&& let Some(argument) = written_arguments.first()
{
return Known::Yes((
crate::sema::types::parse_type_spelling(&format!("{pointer}<{argument}>")),
path.to_path_buf(),
));
}
if names_define_static_array(&callee)
&& let Some(first) =
crate::sema::call_syntax::arguments_of(call).and_then(|nodes| nodes.into_iter().next())
&& let Known::Yes((argument, _)) = type_of_expression_memoed(
memo, shapes, index, declaring, scopes, root, path, &first, 0,
)
&& let Some(element) = range_element_of(as_a_range(&argument))
{
let element = crate::sema::types::parse_type_spelling(&element);
let element = Arc::new(Type::Qualified {
of: Arc::new(element),
});
let array = Arc::new(Type::Array {
of: element,
extent: None,
});
return Known::Yes((
Type::Reference {
to: array,
rvalue: false,
},
path.to_path_buf(),
));
}
if let Some(algorithm) = a_ranges_algorithm_the_call_names(&callee) {
let arguments = crate::sema::call_syntax::arguments_of(call).unwrap_or_default();
match algorithm.as_str() {
"find" | "find_if" | "find_if_not" | "max" | "min" | "max_element" | "min_element"
| "lower_bound" | "upper_bound" | "equal_range" | "search" => {
if let Some(element) = arguments.first().and_then(|first| {
element_of_a_range_expression(
memo, index, declaring, scopes, root, path, first, 0,
)
}) {
return element;
}
}
"count" | "count_if" | "distance" | "ssize" => {
return Known::Yes((
crate::sema::types::parse_type_spelling("std::ptrdiff_t"),
path.to_path_buf(),
));
}
"size" => {
return Known::Yes((
crate::sema::types::parse_type_spelling("std::size_t"),
path.to_path_buf(),
));
}
"subrange" => {
if let Some(first) = arguments.first()
&& let Some(element) = element_of_an_iterator_expression(
memo, index, declaring, scopes, root, path, first, 0,
)
{
return element;
}
}
_ => {}
}
}
if let Some(spelling) = a_callee_that_names_a_type(index, path, &callee) {
return Known::Yes((
crate::sema::types::parse_type_spelling(&spelling),
path.to_path_buf(),
));
}
let resolved = declaration_of_a_callee(
memo, shapes, index, declaring, scopes, root, path, &callee, written,
);
let known_so_far = match resolved {
Known::Yes(named) => match named.what_a_call_has(
shapes,
index,
declaring,
scopes,
root,
path,
&written_arguments,
&argument_types,
) {
Some(type_of) => return Known::Yes((type_of, named.file(path))),
None => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
},
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
};
if let Some(returns) = the_return_the_overloads_agree_on(
index,
path,
&the_names_the_call_may_use(&callee),
&written_arguments,
&argument_types,
crate::sema::call_syntax::arguments_of(call)
.map(|arguments| arguments.len())
.unwrap_or_default(),
memo,
declaring,
scopes,
root,
depth,
) {
return Known::Yes((
crate::sema::types::parse_type_spelling(&returns),
path.to_path_buf(),
));
}
known_so_far
}
pub(crate) fn the_factory_the_call_names(
callee: &cpp_parser::CppSyntaxNode,
) -> Option<&'static str> {
let spelled = callee.text().to_string();
let spelled = spelled.trim();
let bare = match spelled.find('<') {
Some(at) => spelled[..at].trim(),
None => spelled,
};
let last = bare.rsplit("::").next().unwrap_or(bare);
match last {
"make_shared" => Some("shared_ptr"),
"make_unique" | "make_unique_for_overwrite" => Some("unique_ptr"),
_ => None,
}
}
pub(crate) fn names_the_identity_function(callee: &cpp_parser::CppSyntaxNode) -> bool {
let spelled = callee.text().to_string();
let spelled = spelled.trim();
let bare = match spelled.find('<') {
Some(at) => spelled[..at].trim(),
None => spelled,
};
matches!(
bare,
"std::move" | "std::forward" | "::std::move" | "::std::forward"
)
}
pub(crate) fn the_name_before_its_template_arguments(
callee: &cpp_parser::CppSyntaxNode,
) -> Option<String> {
let kind = CppSyntaxKind::from(callee.kind());
if !matches!(
kind,
CppSyntaxKind::NameExpr | CppSyntaxKind::IdentifierExpr
) {
return None;
}
let text = callee.text().to_string();
let text = text.trim();
let open = text.find('<')?;
if open == 0 || !text.ends_with('>') {
return None;
}
let name = &text[..open];
let names_something = name
.chars()
.all(|character| character.is_alphanumeric() || character == '_' || character == ':');
names_something.then(|| name.to_string())
}
pub(crate) fn a_ranges_algorithm_the_call_names(
callee: &cpp_parser::CppSyntaxNode,
) -> Option<String> {
let written = callee.text().to_string();
let written = written.trim();
let last = written.rsplit("::").next()?;
let in_the_ranges_namespace = written.contains("ranges::");
let is_an_algorithm = matches!(
last,
"find"
| "find_if"
| "find_if_not"
| "max"
| "min"
| "max_element"
| "min_element"
| "count"
| "count_if"
| "distance"
| "size"
| "ssize"
| "subrange"
| "lower_bound"
| "upper_bound"
| "equal_range"
| "search"
);
(in_the_ranges_namespace && is_an_algorithm).then(|| last.to_string())
}
pub(crate) fn a_callee_that_names_a_type(
index: &ProjectIndex,
path: &Path,
callee: &cpp_parser::CppSyntaxNode,
) -> Option<String> {
let spelled = callee.text().to_string();
let spelled = spelled.trim();
if spelled.is_empty() || spelled.contains(' ') {
return None;
}
let bare = match spelled.find('<') {
Some(at) => spelled[..at].trim(),
None => spelled,
};
let names_a_type = match index.definition(bare, path) {
Known::Yes(found) => found.fact.kind == crate::DeclKind::Type,
Known::Unknown(UnknownReason::Ambiguous(_)) => {
index.definitions(bare, path).value().is_some_and(|found| {
!found.found.is_empty()
&& found
.found
.iter()
.all(|declaration| declaration.fact.kind == crate::DeclKind::Type)
})
}
Known::Unknown(_) | Known::No => false,
};
names_a_type.then(|| spelled.to_string())
}
pub(crate) fn the_names_the_call_may_use(callee: &cpp_parser::CppSyntaxNode) -> Vec<String> {
let spelled = callee.text().to_string();
let spelled = spelled.trim();
let bare = match spelled.find('<') {
Some(at) => spelled[..at].trim(),
None => spelled,
};
let last = bare.rsplit("::").next().unwrap_or(bare);
let mut names = vec![bare.to_string()];
if last != bare {
names.push(last.to_string());
}
names
}
pub(crate) fn the_return_the_overloads_agree_on(
index: &ProjectIndex,
path: &Path,
names: &[String],
written_arguments: &[Type],
argument_types: &[Type],
how_many_arguments: usize,
memo: &TypeMemo,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
depth: usize,
) -> Option<String> {
for name in names {
let Known::Yes(found) = index.definitions(name, path) else {
continue;
};
let mut agreed: Option<String> = None;
let mut any = false;
for candidate in found
.found
.iter()
.filter(|declaration| declaration.fact.kind == crate::DeclKind::Function)
{
if candidate
.fact
.modifiers
.contains(crate::summary::DeclModifiers::DELETED)
{
continue;
}
let written: String = match candidate.fact.returns.as_deref() {
Some(written) => written.to_string(),
None => match the_return_the_body_gives_back(
memo, index, declaring, scopes, root, path, depth, candidate,
) {
Some(written) => written,
None => continue,
},
};
if !a_candidate_that_can_be_called_this_way(
candidate.fact.parameter_list(),
argument_types,
how_many_arguments,
) {
continue;
}
let substituted =
if written_arguments.is_empty() || candidate.fact.parameters().is_empty() {
written.clone()
} else {
let arguments: Vec<String> = written_arguments
.iter()
.map(|one| one.to_string())
.collect();
crate::sema::types::substituted_spelling(
&written,
candidate.fact.parameters(),
&arguments,
)
};
let still_unsubstituted =
candidate.fact.parameters().iter().any(|parameter| {
!parameter.is_empty() && substituted.contains(parameter.as_str())
});
if still_unsubstituted {
continue;
}
let read_as_auto_reads_it = read_the_way_auto_does(&substituted);
if read_as_auto_reads_it.is_empty() {
continue;
}
any = true;
match &agreed {
None => agreed = Some(read_as_auto_reads_it),
Some(previous) if *previous == read_as_auto_reads_it => {}
Some(_) => return None,
}
}
if any && agreed.is_some() {
return agreed;
}
}
None
}
pub(crate) fn a_candidate_that_can_be_called_this_way(
parameter_list: Option<&str>,
argument_types: &[Type],
how_many_arguments: usize,
) -> bool {
let Some(parameter_list) = parameter_list else {
return false;
};
let parameters = crate::sema::overload::parameters_in(parameter_list).0;
let a_pack = parameter_list.contains("...");
if a_pack {
let fixed = parameters.len().saturating_sub(1);
if how_many_arguments < fixed {
return false;
}
} else if parameters.len() != how_many_arguments {
return false;
}
if argument_types.len() != how_many_arguments {
return true;
}
parameters
.iter()
.zip(argument_types)
.all(|(parameter, argument)| {
!crate::sema::convert::conversion(argument, parameter, |_| None).is_refused()
})
}
pub(crate) fn read_the_way_auto_does(written: &str) -> String {
let mut spelling = written.trim();
while let Some(rest) = spelling.strip_prefix("const ") {
spelling = rest.trim();
}
while let Some(rest) = spelling.strip_suffix('&') {
spelling = rest.trim();
}
spelling.to_string()
}
pub(crate) fn iterator_element_type(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
callee: &cpp_parser::CppSyntaxNode,
) -> Option<Known<(Type, PathBuf)>> {
let member = crate::sema::resolve::member_access_at(root, end_of_the_written_name(callee))?;
if !matches!(
member.member.as_str(),
"begin"
| "cbegin"
| "rbegin"
| "end"
| "cend"
| "rend"
| "find"
| "lower_bound"
| "upper_bound"
) {
return None;
}
let Known::Yes((object, file)) = type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&member.object,
0,
) else {
return None;
};
let element = range_element_of(&object)?;
Some(Known::Yes((
crate::sema::types::parse_type_spelling(&element),
file,
)))
}
pub(crate) fn written_template_arguments(callee: &cpp_parser::CppSyntaxNode) -> Vec<Type> {
let Some(list) = callee
.descendants()
.find(|node| CppSyntaxKind::from(node.kind()) == CppSyntaxKind::TemplateArgumentList)
else {
return Vec::new();
};
crate::sema::types::read_template_arguments(&list)
}
pub(crate) fn qualified_from_the_index(
index: &ProjectIndex,
from: &Path,
class: &str,
) -> Option<String> {
if class.contains("::") {
return None;
}
let declared = index.files_declaring(class, from);
let found = declared
.into_iter()
.find(|declared| declared.fact.kind == crate::DeclKind::Type)?;
let scope = found.fact.scope.as_deref()?;
(!scope.is_empty()).then(|| format!("{scope}::{class}"))
}
pub(crate) fn declaration_of_a_callee(
memo: &TypeMemo,
shapes: &crate::sema::declarations::ShapeTable,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
callee: &cpp_parser::CppSyntaxNode,
written: &str,
) -> Known<NamedDeclaration> {
if let Some(access) = crate::sema::resolve::member_access_of(callee) {
let object = match type_of_expression_memoed(
memo,
shapes,
index,
declaring,
scopes,
root,
path,
&access.object,
0,
) {
Known::Yes((type_of, _)) => type_of,
Known::Unknown(reason) => return Known::Unknown(reason),
Known::No => return Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
};
let class = if access.arrow
&& let Some((reached, _)) = crate::completion::the_class_after_the_operator(
index, scopes, root, path, &object, true,
) {
reached
} else {
let Some(own) = member_access_class(&object) else {
return Known::Unknown(UnknownReason::UnknownType(Box::from(object.to_string())));
};
own
};
let (class, arguments) =
member_access_class_and_arguments(shapes, index, scopes, root, path, &class, &object);
let bindings = member_bindings(index, scopes, root, path, &class, &arguments);
if crate::probes::inference() {
eprintln!(
"[inference] callee: object {object:?} -> class {class:?}, arguments {arguments:?}, bindings empty {}",
bindings.is_empty()
);
}
let written_arguments: Vec<String> = arguments
.iter()
.map(|argument| argument.to_string())
.collect();
let declared = member_candidates(
shapes,
index,
scopes,
root,
path,
&class,
&access.member,
Some(&written_arguments),
);
let callable: Vec<(DeclFact, PathBuf)> = declared
.into_iter()
.filter(|(fact, _)| {
!object.is_const() || fact.modifiers.contains(crate::DeclModifiers::CONST)
})
.collect();
if callable.len() > 1
&& let Some(call) = the_call_around(callee)
&& let Some(types) =
the_types_of_the_arguments(memo, index, declaring, scopes, root, path, &call)
&& let Some(chosen) = the_one_the_arguments_select(&types, &callable, &[])
&& let Some((fact, file)) = callable.get(chosen)
{
if crate::probes::inference() {
eprintln!(
"[inference] callee: {} candidate(s), the arguments chose {chosen}",
callable.len()
);
}
return Known::Yes(NamedDeclaration::Indexed(
fact.clone(),
file.clone(),
bindings,
));
}
return match member_fact(
shapes,
index,
scopes,
root,
path,
&class,
&access.member,
Some(&written_arguments),
) {
Known::Yes((fact, file)) => Known::Yes(NamedDeclaration::Indexed(fact, file, bindings)),
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
};
}
if let Some(call) = the_call_around(callee)
&& let Known::Yes(bindings) =
crate::sema::resolve::definitions_at(scopes, root, end_of_the_written_name(callee))
&& bindings.len() > 1
&& let Some(types) =
the_types_of_the_arguments(memo, index, declaring, scopes, root, path, &call)
{
let candidates: Vec<(DeclFact, PathBuf)> = bindings
.iter()
.map(|binding| {
(
fact_from_binding_with(
crate::sema::declarations::shapes_from(shapes, root),
root,
"",
binding,
),
path.to_path_buf(),
)
})
.collect();
let explicit_arguments: Vec<String> = call
.children()
.next()
.map(|callee| written_template_arguments(&callee))
.unwrap_or_default()
.iter()
.map(Type::to_string)
.collect();
if let Some(chosen) = the_one_the_arguments_select(&types, &candidates, &explicit_arguments)
&& let Some(binding) = bindings.get(chosen)
{
return Known::Yes(NamedDeclaration::Here(binding.clone()));
}
}
if matches!(
crate::sema::resolve::definition_at(scopes, root, end_of_the_written_name(callee)),
Known::No | Known::Unknown(UnknownReason::NotDeclaredHere(_))
) && let Some(member) =
a_member_of_the_enclosing_class(index, scopes, root, path, callee, true)
{
return Known::Yes(NamedDeclaration::Indexed(
member.fact,
member.file,
crate::sema::types::TypeBindings::new(Vec::new(), Vec::new()),
));
}
let known = declaration_of_expression(index, scopes, root, path, callee);
let known = match &known {
Known::No
| Known::Unknown(UnknownReason::NotDeclaredHere(_))
| Known::Unknown(UnknownReason::Ambiguous(_)) => {
match the_name_before_its_template_arguments(callee) {
Some(bare) => {
let start = usize::from(callee.text_range().start());
match crate::sema::resolve::definition_at(scopes, root, start + bare.len()) {
Known::Yes(binding) => Known::Yes(NamedDeclaration::Here(binding)),
_ => match index.definition(&bare, path) {
Known::Yes(found) => Known::Yes(NamedDeclaration::Indexed(
found.fact,
found.file,
crate::sema::types::TypeBindings::new(Vec::new(), Vec::new()),
)),
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::No,
},
}
}
None => known,
}
}
_ => known,
};
let Known::Unknown(UnknownReason::Ambiguous(name)) = &known else {
return known;
};
let Some(call) = the_call_around(callee) else {
return known;
};
match the_declaration_the_arguments_pick(
memo,
index,
declaring,
scopes,
root,
path,
&call,
name.as_ref(),
) {
Some((fact, file)) => Known::Yes(NamedDeclaration::Indexed(
fact,
file,
TypeBindings::default(),
)),
None => known,
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct Callee {
pub file: PathBuf,
pub name_offset: usize,
pub parameters: Option<String>,
}
pub(crate) fn callees_of_a_call(
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
call: &cpp_parser::CppSyntaxNode,
) -> Known<Vec<Callee>> {
let memo = TypeMemo::default();
let shapes = crate::sema::declarations::ShapeTable::new();
let written = call.text().to_string();
let written = written.trim();
let Some(callee) = call.children().next() else {
return Known::Unknown(UnknownReason::UnknownType(Box::from(written)));
};
if let Some(access) = crate::sema::resolve::member_access_of(&callee) {
let members = member_callees(&memo, index, declaring, scopes, root, path, &access);
return match members {
Known::Yes(found) if !found.is_empty() => Known::Yes(found),
other => match other {
Known::Unknown(reason) => Known::Unknown(reason),
_ => match callee_of_a_call(&shapes, index, declaring, scopes, root, path, call) {
Known::Yes(one) => Known::Yes(vec![one]),
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
},
},
};
}
let offset = end_of_the_written_name(&callee);
match crate::sema::resolve::definitions_at(scopes, root, offset) {
Known::Yes(bindings) if !bindings.is_empty() => Known::Yes(
bindings
.iter()
.map(|binding| Callee {
file: path.to_path_buf(),
name_offset: binding.name_range.start_offset,
parameters: None,
})
.collect(),
),
Known::Yes(_) => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
Known::Unknown(UnknownReason::NotDeclaredHere(name))
| Known::Unknown(UnknownReason::Ambiguous(name)) => match index.definitions(&name, path) {
Known::Yes(found) => Known::Yes(
found
.found
.iter()
.map(|declaration| Callee {
file: declaration.file.clone(),
name_offset: declaration.fact.name_range.start_offset,
parameters: declaration.fact.parameter_list().map(str::to_string),
})
.collect(),
),
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
},
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
}
}
pub(crate) fn the_call_around(
callee: &cpp_parser::CppSyntaxNode,
) -> Option<cpp_parser::CppSyntaxNode> {
let mut node = callee.parent();
for _ in 0..4 {
let inner = node?;
if cpp_parser::CppSyntaxKind::from(inner.kind()) == cpp_parser::CppSyntaxKind::CallExpr {
return Some(inner);
}
node = inner.parent();
}
None
}
pub(crate) fn the_declaration_the_arguments_pick(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
call: &cpp_parser::CppSyntaxNode,
name: &str,
) -> Option<(DeclFact, PathBuf)> {
let name = the_name_without_its_arguments(name);
let Known::Yes(definitions) = index.definitions(name, path) else {
return None;
};
if definitions.found.len() < 2 {
return None;
}
let candidates: Vec<(DeclFact, PathBuf)> = definitions
.found
.iter()
.map(|definition| (definition.fact.clone(), definition.file.clone()))
.collect();
let types = the_types_of_the_arguments(memo, index, declaring, scopes, root, path, call)?;
let explicit_arguments: Vec<String> = call
.children()
.next()
.map(|callee| written_template_arguments(&callee))
.unwrap_or_default()
.iter()
.map(Type::to_string)
.collect();
let chosen = the_one_the_arguments_select(&types, &candidates, &explicit_arguments)?;
candidates.get(chosen).cloned()
}
pub(crate) fn the_name_without_its_arguments(written: &str) -> &str {
let Some(open) = written.find('<') else {
return written;
};
let mut depth = 0i32;
for (at, character) in written[open..].char_indices() {
match character {
'<' => depth += 1,
'>' => {
depth -= 1;
if depth == 0 {
let close = open + at;
return if close + character.len_utf8() == written.len() {
&written[..open]
} else {
written
};
}
}
_ => {}
}
}
written
}
pub(crate) fn the_types_of_the_arguments(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
call: &cpp_parser::CppSyntaxNode,
) -> Option<Vec<Known<String>>> {
let arguments = crate::sema::call_syntax::arguments_of(call)?;
Some(
arguments
.iter()
.map(|argument| {
match type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
argument,
0,
) {
Known::Yes((type_of, _)) => Known::Yes(type_of.to_string()),
Known::No => Known::No,
Known::Unknown(reason) => Known::Unknown(reason),
}
})
.collect(),
)
}
pub(crate) fn the_one_the_arguments_select(
types: &[Known<String>],
candidates: &[(DeclFact, PathBuf)],
explicit_arguments: &[String],
) -> Option<usize> {
let usable: Vec<usize> = (0..candidates.len())
.filter(|at| {
!candidates[*at]
.0
.modifiers
.contains(crate::DeclModifiers::DELETED)
})
.collect();
if usable.is_empty() {
return None;
}
let built: Vec<crate::sema::overload::Candidate> = usable
.iter()
.enumerate()
.map(|(at, &index)| {
let (fact, _) = &candidates[index];
let (declared, variadic) = fact
.parameter_list()
.map(crate::sema::overload::parameters_in)
.unwrap_or_default();
let names = fact.parameters().to_vec();
let declared_for_ordering = declared.clone();
let substituted = match crate::sema::deduction::deduce_with_written(
&names,
&declared,
types,
explicit_arguments,
) {
Some(deduced) => (
declared
.iter()
.map(|spelling| {
crate::sema::types::substituted_spelling(spelling, &names, &deduced)
})
.collect::<Vec<String>>(),
true,
),
None => (declared, !names.is_empty()),
};
let candidate = crate::sema::overload::Candidate::new(
substituted.0,
variadic,
format!("declaration {at}"),
);
if substituted.1 {
candidate.with_declaration(declared_for_ordering, names.to_vec())
} else {
candidate
}
})
.collect();
if crate::probes::inference() {
eprintln!(
"[inference] pick among {} candidates ({} usable), argument types {types:?} written {explicit_arguments:?}",
candidates.len(),
usable.len()
);
for (at, (fact, _)) in candidates.iter().enumerate() {
eprintln!(
"[inference] candidate {at}: bits={} deleted={} params={:?}",
fact.modifiers.bits(),
fact.modifiers.contains(crate::DeclModifiers::DELETED),
fact.parameter_list()
);
}
for (at, (fact, _)) in candidates.iter().enumerate() {
eprintln!(
"[inference] candidate {at}: scope {:?} returns {:?} params {:?}",
fact.scope,
fact.returns,
fact.parameter_list()
);
}
}
let choice = crate::sema::overload::choose(types, &built);
if crate::probes::inference() {
eprintln!("[inference] choice: {choice:?}");
}
match choice {
crate::sema::overload::Choice::One(at) => usable.get(at).copied(),
crate::sema::overload::Choice::Ambiguous => {
let written = types.iter().find_map(|argument| match argument {
Known::Yes(spelling) => the_character_width(spelling),
_ => None,
})?;
let definite: Vec<usize> = usable
.iter()
.filter(|at| {
let (fact, _) = &candidates[**at];
fact.parameter_list()
.and_then(|list| {
crate::sema::overload::parameters_in(list)
.0
.into_iter()
.next()
})
.and_then(|first| the_character_width(&first))
== Some(written)
})
.copied()
.collect();
match definite[..] {
[only] => Some(only),
_ => None,
}
}
crate::sema::overload::Choice::None => None,
}
}
pub(crate) fn the_character_width(spelling: &str) -> Option<bool> {
if spelling.contains("wchar_t")
|| spelling.contains("wstring")
|| spelling.contains("wformat")
|| spelling.contains("wint_t")
{
return Some(true);
}
if spelling.contains("char") || spelling.contains("string") {
return Some(false);
}
None
}
pub(crate) fn member_callees(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
access: &crate::sema::resolve::MemberAccess,
) -> Known<Vec<Callee>> {
let object = match type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&access.object,
0,
) {
Known::Yes((type_of, _)) => type_of,
Known::Unknown(reason) => return Known::Unknown(reason),
Known::No => {
return Known::Unknown(UnknownReason::UnknownType(Box::from(
access.object.text().to_string(),
)));
}
};
let Some(class) = member_access_class(&object) else {
return Known::Unknown(UnknownReason::UnknownType(Box::from(object.to_string())));
};
let found = match members_of(index, scopes, root, path, &class) {
Known::Yes(found) => found,
Known::Unknown(reason) => return Known::Unknown(reason),
Known::No => return Known::Unknown(UnknownReason::NotDeclaredHere(Box::from(class))),
};
let wanted = &*access.member;
let candidates: Vec<Callee> = found
.members
.iter()
.filter(|member| member.fact.name == wanted)
.map(|member| Callee {
file: member.file.clone(),
name_offset: member.fact.name_range.start_offset,
parameters: member.fact.parameter_list().map(str::to_string),
})
.collect();
Known::Yes(candidates)
}
pub(crate) fn callee_of_a_call(
shapes: &crate::sema::declarations::ShapeTable,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
call: &cpp_parser::CppSyntaxNode,
) -> Known<Callee> {
let memo = TypeMemo::default();
let written = call.text().to_string();
let written = written.trim();
let Some(callee) = call.children().next() else {
return Known::Unknown(UnknownReason::UnknownType(Box::from(written)));
};
match declaration_of_a_callee(
&memo, shapes, index, declaring, scopes, root, path, &callee, written,
) {
Known::Yes(named) => Known::Yes(Callee {
file: named.file(path),
name_offset: named.name_offset(),
parameters: named.parameter_list(),
}),
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::Unknown(UnknownReason::UnknownType(Box::from(written))),
}
}
pub(crate) fn a_members_answer_as_a_type(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class_type: &Type,
returns: &str,
) -> String {
let mut class_type = class_type.clone();
for _ in 0..4 {
let Some(name) = class_type.class_name().map(str::to_string) else {
return returns.to_string();
};
let Some(target) = index
.files_declaring(&name, path)
.into_iter()
.find(|declared| {
declared.fact.kind == crate::DeclKind::Type && declared.fact.type_of.is_some()
})
.and_then(|declared| declared.fact.type_of.clone())
else {
break;
};
let resolved = crate::sema::types::parse_type_spelling(&target);
let Some(resolved_name) = resolved.class_name() else {
break;
};
let qualified = crate::index::project::qualified_from_the_index(index, path, resolved_name)
.unwrap_or_else(|| resolved_name.to_string());
if qualified == name {
break;
}
let arguments: Vec<String> = resolved
.arguments()
.iter()
.map(|argument| argument.to_string())
.collect();
let resolved = crate::sema::types::parse_type_spelling(&match arguments.is_empty() {
true => qualified,
false => format!("{qualified}<{}>", arguments.join(", ")),
});
class_type = match class_type.is_const() && !resolved.is_const() {
true => crate::sema::types::Type::Qualified {
of: std::sync::Arc::new(resolved),
},
false => resolved,
};
}
let Some(class) = class_type.class_name() else {
return returns.to_string();
};
let arguments: Vec<String> = class_type
.arguments()
.iter()
.map(|argument| argument.to_string())
.collect();
let parameters = index.template_parameters_for(class, path, &arguments);
let defaults = index.template_parameter_defaults_for(class, path, &arguments);
let substituted = crate::sema::types::substituted_spelling_with_defaults(
returns,
¶meters,
&defaults,
&arguments,
);
let (leading, core, trailing) = split_the_operators_of(&substituted);
if core.is_empty()
|| !core
.chars()
.all(|character| character.is_alphanumeric() || character == '_')
{
return substituted;
}
let Known::Yes((fact, _)) = member_fact(
&crate::sema::declarations::ShapeTable::new(),
index,
scopes,
root,
path,
&the_class_spelling(&class_type),
&core,
None,
) else {
return substituted;
};
let Some(target) = fact.type_of.as_deref() else {
return substituted;
};
let target = crate::sema::types::substituted_spelling_with_defaults(
target,
¶meters,
&defaults,
&arguments,
);
let target = a_spelling_through_the_aliases(
index,
scopes,
root,
path,
&class_type,
&[],
&target,
MAX_ALIAS_HOPS,
);
let target = crate::sema::types::substituted_spelling_with_defaults(
&target,
¶meters,
&defaults,
&arguments,
);
format!("{leading}{target}{trailing}")
}