use crate::Known;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Conversion {
Same,
Implicit,
NeedsABuild,
Refused,
Unknown,
}
impl Conversion {
pub fn is_refused(self) -> bool {
self == Conversion::Refused
}
}
pub fn strip_references(parameter: &str) -> &str {
let mut written = parameter.trim();
while let Some(rest) = written.strip_prefix("const ") {
written = rest.trim();
}
while let Some(rest) = written.strip_suffix('&') {
written = rest.trim();
}
written
}
pub fn conversion(
from: &crate::sema::types::Type,
written: &str,
answer_the_class_question: impl FnOnce(&str) -> Option<bool>,
) -> Conversion {
let target = crate::sema::types::parse_type_spelling(written);
match from.convertible_to(&target) {
Known::Yes(()) => return Conversion::Implicit,
Known::No => return Conversion::Refused,
Known::Unknown(_) => {}
}
let bare = crate::sema::types::parse_type_spelling(strip_references(written));
let Some(class) = bare.class_name().filter(|class| !class.is_empty()) else {
return Conversion::Unknown;
};
if names_a_template_parameter(class) {
return Conversion::Unknown;
}
match answer_the_class_question(class) {
Some(true) => Conversion::NeedsABuild,
Some(false) => Conversion::Refused,
None => Conversion::Unknown,
}
}
pub(crate) fn names_a_template_parameter_for_a_check(spelled: &str) -> bool {
let bare = spelled
.trim()
.trim_start_matches("const ")
.trim_end_matches(['&', '*', ' ']);
names_a_template_parameter(bare)
}
fn names_a_template_parameter(class: &str) -> bool {
let mut characters = class.chars();
let Some(first) = characters.next() else {
return false;
};
if class.len() == 1 {
return first.is_ascii_uppercase();
}
first == '_'
&& characters
.next()
.is_some_and(|second| second.is_ascii_uppercase())
}