pub mod traits;
pub mod transforms;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Answer {
Boolean(bool),
UndecidedBoolean,
Type(crate::sema::types::Type),
Unmodelled,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Builtin {
pub name: &'static str,
pub arity: Option<usize>,
pub kind: Kind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Kind {
Trait(traits::Trait),
Transform(transforms::Transform),
Unmodelled,
}
pub fn named(name: &str) -> Option<Builtin> {
if let Some(found) = traits::named(name) {
return Some(found);
}
transforms::named(name)
}
pub fn answer(builtin: Builtin, arguments: &[String]) -> Answer {
match builtin.kind {
Kind::Trait(question) => match traits::decide(question, arguments) {
Some(value) => Answer::Boolean(value),
None => Answer::UndecidedBoolean,
},
Kind::Transform(transform) => transforms::apply(transform, arguments),
Kind::Unmodelled => Answer::Unmodelled,
}
}
pub fn split_a_builtin_spelling(written: &str) -> Option<(Builtin, Vec<String>)> {
let written = written.trim();
let open = written.find(['(', '<'])?;
let closer = if written.as_bytes().get(open) == Some(&b'(') {
')'
} else {
'>'
};
if !written.ends_with(closer) {
return None;
}
let builtin = named(written[..open].trim())?;
let inner = &written[open + 1..written.len() - 1];
Some((builtin, split_arguments(inner)))
}
pub fn split_arguments(written: &str) -> Vec<String> {
let mut parts = Vec::new();
let mut current = String::new();
let mut depth = 0i32;
for character in written.chars() {
match character {
'<' | '(' | '[' => depth += 1,
'>' | ')' | ']' => depth -= 1,
',' if depth == 0 => {
parts.push(current.trim().to_string());
current.clear();
continue;
}
_ => {}
}
current.push(character);
}
let last = current.trim();
if !last.is_empty() || !parts.is_empty() {
parts.push(last.to_string());
}
parts
}
pub fn folded(written: &str) -> String {
let Some((builtin, arguments)) = split_a_builtin_spelling(written) else {
return written.to_string();
};
match answer(builtin, &arguments) {
Answer::Boolean(value) => value.to_string(),
_ => written.to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_decided_builtin_folds_to_the_word_a_pattern_is_written_with() {
assert_eq!(folded("__is_same(int, int)"), "true");
assert_eq!(folded("__is_same(int, double)"), "false");
assert_eq!(folded("__is_pointer(int*)"), "true");
assert_eq!(folded("__is_pointer(int)"), "false");
}
#[test]
fn an_undecided_builtin_and_an_ordinary_type_both_come_back_unchanged() {
for unchanged in [
"__is_constructible(_Ty, _Args...)",
"__is_pointer(_Ty)",
"__is_pointer(Widget)",
"vector<int>",
"int",
] {
assert_eq!(folded(unchanged), unchanged, "this one is not decided");
}
}
#[test]
fn the_two_forms_a_builtin_is_written_in_are_both_read() {
assert_eq!(
split_a_builtin_spelling("__is_pointer(int*)")
.map(|(builtin, arguments)| (builtin.name, arguments)),
Some(("__is_pointer", vec!["int*".to_string()]))
);
assert_eq!(
split_a_builtin_spelling("__type_pack_element<0, _Types...>")
.map(|(builtin, arguments)| (builtin.name, arguments)),
Some((
"__type_pack_element",
vec!["0".to_string(), "_Types...".to_string()]
)),
"a template-id form is split the same way a call is"
);
assert!(
split_a_builtin_spelling("vector<int>").is_none(),
"an ordinary class is not a builtin"
);
}
#[test]
fn arguments_are_split_where_the_language_splits_them() {
assert_eq!(split_arguments("A, B"), vec!["A", "B"]);
assert_eq!(
split_arguments("vector<int>, pair<int, int>"),
vec!["vector<int>", "pair<int, int>"]
);
assert_eq!(split_arguments(""), Vec::<String>::new());
}
}