#![allow(dead_code)]
use std::collections::HashMap;
use crate::sema::symbol::Known;
pub(crate) fn deduce(
names: &[String],
parameters: &[String],
arguments: &[Known<String>],
) -> Option<Vec<String>> {
if names.is_empty() {
return None;
}
let mut bound: HashMap<String, String> = HashMap::new();
for (parameter, argument) in parameters.iter().zip(arguments) {
let Known::Yes(argument) = argument else {
continue;
};
let parameter = the_shape_of(parameter);
let argument = the_shape_of(argument);
if names.iter().any(|name| name == ¶meter) {
if !bind(&mut bound, ¶meter, &argument) {
return None;
}
continue;
}
if let Some((before, name, after)) = around_a_name(¶meter, names) {
let Some(rest) = argument.strip_prefix(&before) else {
continue;
};
let Some(rest) = rest.strip_suffix(&after) else {
continue;
};
if rest.is_empty() {
continue;
}
if !bind(&mut bound, &name, rest) {
return None;
}
continue;
}
}
let mut deduced = Vec::with_capacity(names.len());
for name in names {
deduced.push(bound.get(name.as_str())?.clone());
}
Some(deduced)
}
fn bind(bound: &mut HashMap<String, String>, name: &str, argument: &str) -> bool {
match bound.get(name) {
Some(known) => known == argument,
None => {
bound.insert(name.to_string(), argument.to_string());
true
}
}
}
fn around_a_name(parameter: &str, names: &[String]) -> Option<(String, String, String)> {
for name in names {
let mut from = 0usize;
while let Some(at) = parameter[from..].find(name.as_str()) {
let start = from + at;
let end = start + name.len();
let before = ¶meter[..start];
let after = ¶meter[end..];
let whole_start = start == 0
|| !parameter[..start]
.chars()
.next_back()
.is_some_and(|character| character.is_alphanumeric() || character == '_');
let whole_end = end == parameter.len()
|| !parameter[end..]
.chars()
.next()
.is_some_and(|character| character.is_alphanumeric() || character == '_');
if whole_start && whole_end && !(before.is_empty() && after.is_empty()) {
return Some((
before.trim().to_string(),
name.clone(),
after.trim().to_string(),
));
}
from = end;
}
}
None
}
fn the_shape_of(spelling: &str) -> String {
let mut text = spelling.trim().to_string();
loop {
let trimmed = text.trim();
if let Some(before) = trimmed
.strip_suffix("&&")
.or_else(|| trimmed.strip_suffix('&'))
{
text = before.trim_end().to_string();
} else {
break;
}
}
loop {
let trimmed = text.trim_start();
if let Some(after) = trimmed
.strip_prefix("const ")
.or_else(|| trimmed.strip_prefix("volatile "))
{
text = after.trim_start().to_string();
} else {
break;
}
}
text.split_whitespace().collect::<Vec<_>>().join(" ")
}
pub fn template_parameters_before(source: &str, name_offset: usize) -> Vec<String> {
let before = &source[..name_offset.min(source.len())];
let Some(at) = before.rfind("template") else {
return Vec::new();
};
let header = &before[at..];
let Some(open) = header.find('<') else {
return Vec::new();
};
let Some(close) = header[open..].find('>') else {
return Vec::new();
};
if header[open + close..].contains(';') {
return Vec::new();
}
let inside = &header[open + 1..open + close];
let mut names = Vec::new();
let mut depth = 0i32;
let mut part = String::new();
for character in inside.chars() {
match character {
'<' | '(' | '[' => depth += 1,
'>' | ')' | ']' => depth -= 1,
',' if depth == 0 => {
if let Some(name) = the_name_in(&part) {
names.push(name);
}
part.clear();
continue;
}
_ => {}
}
part.push(character);
}
if let Some(name) = the_name_in(&part) {
names.push(name);
}
names
}
fn the_name_in(parameter: &str) -> Option<String> {
let without_default = parameter.split('=').next().unwrap_or(parameter);
let identifier = without_default
.split(|character: char| !(character.is_alphanumeric() || character == '_'))
.rfind(|word| !word.is_empty())?;
Some(identifier.to_string())
}
#[cfg(test)]
mod tests {
use super::*;
fn yes(spelling: &str) -> Known<String> {
Known::Yes(spelling.to_string())
}
fn names(values: &[&str]) -> Vec<String> {
values.iter().map(|value| (*value).to_string()).collect()
}
fn parameters(values: &[&str]) -> Vec<String> {
values.iter().map(|value| (*value).to_string()).collect()
}
#[test]
fn the_parameter_that_is_just_the_parameter_is_the_commonest_case() {
assert_eq!(
deduce(&names(&["T"]), ¶meters(&["T"]), &[yes("int")]),
Some(names(&["int"]))
);
}
#[test]
fn a_reference_and_a_cv_qualifier_are_the_same_type_seen_two_ways() {
assert_eq!(
deduce(
&names(&["T"]),
¶meters(&["const T&"]),
&[yes("std::string")]
),
Some(names(&["std::string"]))
);
}
#[test]
fn a_shape_is_carried_by_the_argument_and_the_name_is_what_is_inside_it() {
assert_eq!(
deduce(&names(&["T"]), ¶meters(&["T*"]), &[yes("int*")]),
Some(names(&["int"]))
);
}
#[test]
fn a_name_deduced_twice_has_to_agree() {
assert_eq!(
deduce(
&names(&["T"]),
¶meters(&["T", "T"]),
&[yes("int"), yes("int")]
),
Some(names(&["int"])),
"two deductions that agree are one deduction"
);
assert_eq!(
deduce(
&names(&["T"]),
¶meters(&["T", "T"]),
&[yes("int"), yes("long")]
),
None,
"and two that disagree do not compile, so this analysis should not pretend they do"
);
}
#[test]
fn an_argument_nothing_is_known_about_binds_nothing_and_a_later_one_can_still_bind_it() {
assert_eq!(
deduce(
&names(&["T"]),
¶meters(&["T", "const T&"]),
&[
Known::Unknown(crate::sema::symbol::UnknownReason::DependentName),
yes("int")
],
),
Some(names(&["int"])),
"the second parameter still fixes T"
);
}
#[test]
fn a_name_that_stays_unbound_is_a_refusal_and_not_a_guess() {
assert_eq!(
deduce(&names(&["T"]), ¶meters(&["T*"]), &[yes("int")]),
None,
"`int` is not a `T*`"
);
assert_eq!(
deduce(&names(&["T"]), ¶meters(&["int"]), &[yes("int")]),
None,
"a parameter that names no template parameter deduces nothing"
);
}
#[test]
fn a_single_level_template_id_is_deduced_by_what_surrounds_the_name() {
assert_eq!(
deduce(
&names(&["T"]),
¶meters(&["std::vector<T>"]),
&[yes("std::vector<int>")]
),
Some(names(&["int"]))
);
}
#[test]
fn a_shape_the_argument_does_not_have_is_refused_rather_than_approximated() {
assert_eq!(
deduce(
&names(&["T"]),
¶meters(&["std::vector<T>"]),
&[yes("std::map<int, int>")]
),
None,
"`std::map<int, int>` does not begin with `std::vector<`, so nothing binds and the answer is no"
);
}
}