use cpp_parser::CppAstNode;
use super::{Check, CheckContext, DiagnosticCode};
pub struct ArgumentCount;
#[derive(Clone)]
struct Callee {
required: usize,
written: usize,
variadic: bool,
parameters: Vec<String>,
}
impl Check for ArgumentCount {
const CODES: &'static [DiagnosticCode] = &[DiagnosticCode::ArgumentCount];
fn check(context: &mut CheckContext<'_>) {
let callees = callees_in_this_file(context);
for call in context.own::<cpp_parser::CppCallExpr>().collect::<Vec<_>>() {
let Some(callee) = call.get_callee() else {
continue;
};
if let Some(access) = super::member_access_above(callee.syntax()) {
judge_a_member_call(context, &call, &access);
continue;
}
let Some(name) = super::callee_name_of(&callee) else {
continue;
};
if names_a_type(context, &name) {
continue;
}
if let crate::Known::Yes(binding) = crate::sema::resolve::definition_at(
context.scopes(),
context.tree(),
usize::from(callee.syntax().text_range().start()),
) && binding.kind != crate::BindingKind::Function
{
continue;
}
let declared = the_most_permissive_arity(
callees.get(name.as_str()).cloned().unwrap_or_default(),
callees_from_the_index(context, &name),
);
if declared.is_empty() {
continue;
}
let passed = call.get_args().len();
if call.has_a_pack_expansion() {
continue;
}
let declared = match declared.as_slice() {
[only] => only,
several => {
let types: Vec<crate::Known<String>> = call
.get_args()
.iter()
.map(|argument| match context.type_of(argument.syntax()) {
crate::Known::Yes((a_type, _)) => crate::Known::Yes(a_type.to_string()),
crate::Known::No => crate::Known::No,
crate::Known::Unknown(reason) => crate::Known::Unknown(reason),
})
.collect();
let candidates: Vec<crate::sema::overload::Candidate> = several
.iter()
.map(|callee| {
crate::sema::overload::Candidate::new(
callee.parameters.clone(),
callee.variadic,
callee.parameters.join(", "),
)
})
.collect();
match crate::sema::overload::choose(&types, &candidates) {
crate::sema::overload::Choice::One(chosen) => &several[chosen],
crate::sema::overload::Choice::None => match closest(several, passed) {
Some(closest) => closest,
None => continue,
},
crate::sema::overload::Choice::Ambiguous => continue,
}
}
};
if !declared.variadic && passed > declared.written {
context.add(
DiagnosticCode::ArgumentCount,
cpp_parser::source_range(call.get_range()),
name.clone(),
at_most(&name, declared.written),
);
} else if passed < declared.required {
context.add(
DiagnosticCode::ArgumentCount,
cpp_parser::source_range(call.get_range()),
name.clone(),
at_least(&name, declared.required),
);
}
}
}
}
fn callees_in_this_file(
context: &CheckContext<'_>,
) -> std::collections::HashMap<String, Vec<Callee>> {
let mut callees: std::collections::HashMap<String, Vec<Callee>> =
std::collections::HashMap::new();
for node in super::function_definitions(context) {
let Some(parameters) = cpp_parser::CppDeclaration::cast(node.clone())
.and_then(|declaration| declaration.descendants::<cpp_parser::CppParamList>().next())
.map(|parameters| parameters.syntax().clone())
else {
continue;
};
let Some(name) = super::name_declared_by(&node) else {
continue;
};
let mut written = 0usize;
let mut required = 0usize;
let mut variadic = false;
let mut spellings: Vec<String> = Vec::new();
for parameter in parameters.children() {
let kinds: Vec<cpp_parser::CppTokenKind> = parameter
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.map(|token| token.kind().into())
.collect();
if kinds.contains(&cpp_parser::CppTokenKind::Ellipsis) {
variadic = true;
continue;
}
written += 1;
if !kinds.contains(&cpp_parser::CppTokenKind::Assign) {
required += 1;
}
let written_as = parameter.text().to_string();
spellings.push(crate::sema::overload::a_type_without_its_name(&written_as));
}
let variadic = variadic
|| parameters
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| {
cpp_parser::CppTokenKind::from(token.kind())
== cpp_parser::CppTokenKind::Ellipsis
});
if written == 1 && spellings.len() == 1 && spellings[0].trim() == "void" {
written = 0;
required = 0;
spellings.clear();
}
let declared = callees.entry(name).or_default();
if !declared.iter().any(|known| known.parameters == spellings) {
declared.push(Callee {
required,
written,
variadic,
parameters: spellings,
});
}
}
callees
}
fn the_most_permissive_arity(mut here: Vec<Callee>, also: Vec<Callee>) -> Vec<Callee> {
for candidate in also {
match here
.iter_mut()
.find(|known| known.parameters == candidate.parameters)
{
Some(known) => {
known.required = known.required.min(candidate.required);
known.written = known.written.max(candidate.written);
known.variadic |= candidate.variadic;
}
None => here.push(candidate),
}
}
here
}
fn at_most(name: &str, written: usize) -> String {
t!(
"`%{name}` takes %{written} argument(s) and this call passes more",
name = name,
written = written
)
.to_string()
}
fn callees_from_the_index(context: &CheckContext<'_>, name: &str) -> Vec<Callee> {
let visible = context.index().include_closure(context.path);
let mut callees: Vec<Callee> = Vec::new();
for (file, fact) in context.index().every_fact_named(name) {
if fact.kind != crate::DeclKind::Function {
continue;
}
let normalized = crate::file::paths::normalize_path(&file, cfg!(windows));
if !visible.contains(&normalized) {
continue;
}
let Some(parameters) = fact.parameter_list() else {
continue;
};
let Some(callee) = the_callee_in(parameters) else {
continue;
};
callees = the_most_permissive_arity(callees, vec![callee]);
}
callees
}
fn the_callee_in(parameters: &str) -> Option<Callee> {
let inner = parameters
.trim()
.trim_start_matches('(')
.trim_end_matches(')');
let mut depth = 0i32;
let mut written = 0usize;
let mut required = 0usize;
let mut variadic = false;
let mut current = String::new();
let mut spellings: Vec<String> = Vec::new();
let take = |parameter: &str,
written: &mut usize,
required: &mut usize,
variadic: &mut bool,
spellings: &mut Vec<String>| {
let parameter = parameter.trim();
if parameter.is_empty() {
return;
}
if has_an_ellipsis(parameter) {
*variadic = true;
return;
}
*written += 1;
if !parameter.contains('=') {
*required += 1;
}
let without_default = parameter.split('=').next().unwrap_or(parameter).trim();
spellings.push(crate::sema::overload::a_type_without_its_name(
without_default,
));
};
for character in inner.chars() {
match character {
'<' | '(' | '[' => depth += 1,
'>' | ')' | ']' => depth -= 1,
',' if depth == 0 => {
take(
¤t,
&mut written,
&mut required,
&mut variadic,
&mut spellings,
);
current.clear();
continue;
}
_ => {}
}
current.push(character);
}
take(
¤t,
&mut written,
&mut required,
&mut variadic,
&mut spellings,
);
if written == 1 && spellings.len() == 1 && spellings[0].trim() == "void" {
written = 0;
required = 0;
spellings.clear();
}
Some(Callee {
required,
written,
variadic,
parameters: spellings,
})
}
fn closest(candidates: &[Callee], passed: usize) -> Option<&Callee> {
candidates.iter().min_by_key(|callee| {
if passed > callee.written {
passed - callee.written
} else {
callee.required.saturating_sub(passed)
}
})
}
fn at_least(name: &str, required: usize) -> String {
t!(
"`%{name}` needs %{required} argument(s) and this call passes fewer",
name = name,
required = required
)
.to_string()
}
fn has_an_ellipsis(parameter: &str) -> bool {
let bytes = parameter.as_bytes();
let mut at = 0usize;
let mut quoted: Option<u8> = None;
while at < bytes.len() {
let byte = bytes[at];
match quoted {
Some(quote) => {
if byte == b'\\' {
at += 2;
continue;
}
if byte == quote {
quoted = None;
}
}
None => {
if byte == b'"' || byte == b'\'' {
quoted = Some(byte);
} else if parameter[at..].starts_with("...") {
return true;
}
}
}
at += 1;
}
false
}
fn names_a_type(context: &CheckContext<'_>, name: &str) -> bool {
let crate::Known::Yes(definitions) = context.index().definitions(name, context.path) else {
return false;
};
definitions
.found
.iter()
.any(|definition| definition.fact.kind != crate::DeclKind::Function)
}
fn judge_a_member_call(
context: &mut CheckContext<'_>,
call: &cpp_parser::CppCallExpr,
access: &crate::sema::resolve::MemberAccess,
) {
let crate::Known::Yes((a_type, _)) = context.type_of(&access.object) else {
return;
};
let class = a_type.to_string();
let mut members: Vec<Callee> = Vec::new();
if let crate::Known::Yes(own) = context.model.own_members_of(&class) {
for (_, fact) in &own {
if fact.name != access.member {
continue;
}
let Some(parameters) = fact.parameter_list() else {
continue;
};
if let Some(callee) = the_callee_in(parameters) {
members.push(callee);
}
}
}
if members.is_empty() {
let crate::Known::Yes(list) = context.model.members_of(&class) else {
return;
};
members = list
.members
.iter()
.filter(|member| member.fact.name == access.member)
.filter_map(|member| member.fact.parameter_list())
.filter_map(the_callee_in)
.collect();
}
if members.is_empty() {
return;
}
let passed = call.get_args().len();
if members
.iter()
.any(|member| member.variadic || (passed >= member.required && passed <= member.written))
{
return;
}
let Some(declared) = closest(&members, passed) else {
return;
};
let name = access.member.clone();
context.add(
DiagnosticCode::ArgumentCount,
cpp_parser::source_range(call.get_range()),
name.clone(),
if passed > declared.written {
at_most(&name, declared.written)
} else {
at_least(&name, declared.required)
},
);
}