use super::{Answer, Builtin, Kind};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Trait {
Pointer,
LvalueReference,
RvalueReference,
Reference,
Array(ArrayBound),
Void,
Integral,
FloatingPoint,
Unseen,
Same,
Unknown,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArrayBound {
Either,
Bounded,
Unbounded,
}
const TRAITS: &[(&str, Trait)] = &[
("__is_pointer", Trait::Pointer),
("__is_lvalue_reference", Trait::LvalueReference),
("__is_rvalue_reference", Trait::RvalueReference),
("__is_reference", Trait::Reference),
("__is_array", Trait::Array(ArrayBound::Either)),
("__is_bounded_array", Trait::Array(ArrayBound::Bounded)),
("__is_unbounded_array", Trait::Array(ArrayBound::Unbounded)),
("__is_void", Trait::Void),
("__is_integral", Trait::Integral),
("__is_floating_point", Trait::FloatingPoint),
("__is_same", Trait::Same),
("__is_enum", Trait::Unseen),
("__is_union", Trait::Unseen),
("__is_class", Trait::Unseen),
("__is_function", Trait::Unseen),
("__is_member_object_pointer", Trait::Unseen),
("__is_member_function_pointer", Trait::Unseen),
("__is_member_pointer", Trait::Unseen),
("__is_constructible", Trait::Unknown),
("__is_trivially_constructible", Trait::Unknown),
("__is_nothrow_constructible", Trait::Unknown),
("__is_default_constructible", Trait::Unknown),
("__is_copy_constructible", Trait::Unknown),
("__is_move_constructible", Trait::Unknown),
("__is_assignable", Trait::Unknown),
("__is_assignable_no_precondition_check", Trait::Unknown),
("__is_trivially_assignable", Trait::Unknown),
("__is_nothrow_assignable", Trait::Unknown),
("__is_destructible", Trait::Unknown),
("__is_trivially_destructible", Trait::Unknown),
("__is_nothrow_destructible", Trait::Unknown),
("__is_trivially_copyable", Trait::Unknown),
("__is_trivial", Trait::Unknown),
("__is_standard_layout", Trait::Unknown),
("__is_empty", Trait::Unknown),
("__is_polymorphic", Trait::Unknown),
("__is_abstract", Trait::Unknown),
("__is_final", Trait::Unknown),
("__is_aggregate", Trait::Unknown),
("__is_pod", Trait::Unknown),
("__is_base_of", Trait::Unknown),
("__is_pointer_interconvertible_base_of", Trait::Unknown),
("__is_convertible_to", Trait::Unknown),
("__is_nothrow_convertible", Trait::Unknown),
("__is_invocable", Trait::Unknown),
("__is_nothrow_invocable", Trait::Unknown),
("__has_virtual_destructor", Trait::Unknown),
("__is_swappable", Trait::Unknown),
("__is_nothrow_swappable", Trait::Unknown),
("__is_trivially_relocatable", Trait::Unknown),
("__is_scoped_enum", Trait::Unknown),
("__is_nothrow_copy_constructible", Trait::Unknown),
("__is_nothrow_move_constructible", Trait::Unknown),
("__is_trivially_copy_constructible", Trait::Unknown),
("__is_trivially_move_constructible", Trait::Unknown),
("__is_nothrow_copy_assignable", Trait::Unknown),
("__is_nothrow_move_assignable", Trait::Unknown),
("__is_trivially_copy_assignable", Trait::Unknown),
("__is_trivially_move_assignable", Trait::Unknown),
("__is_signed", Trait::Unknown),
("__is_unsigned", Trait::Unknown),
];
pub fn named(name: &str) -> Option<Builtin> {
TRAITS
.iter()
.find(|(spelling, _)| *spelling == name)
.map(|(spelling, question)| Builtin {
name: spelling,
arity: None,
kind: Kind::Trait(*question),
})
}
pub fn decide(question: Trait, arguments: &[String]) -> Option<bool> {
match question {
Trait::Pointer => shape_of(arguments)?.is_pointer(),
Trait::LvalueReference => shape_of(arguments)?.is_reference(false),
Trait::RvalueReference => shape_of(arguments)?.is_reference(true),
Trait::Reference => match shape_of(arguments)? {
Shape::Reference { .. } => Some(true),
Shape::Open => None,
_ => Some(false),
},
Trait::Array(bound) => match shape_of(arguments)? {
Shape::Array(extent) => Some(match bound {
ArrayBound::Either => true,
ArrayBound::Bounded => extent,
ArrayBound::Unbounded => !extent,
}),
Shape::Open => None,
_ => Some(false),
},
Trait::Void => match shape_of(arguments)? {
Shape::Builtin(name) => Some(name == "void"),
Shape::Open => None,
_ => Some(false),
},
Trait::Integral => builtin_kind(arguments, is_an_integral_spelling),
Trait::FloatingPoint => builtin_kind(arguments, is_a_floating_spelling),
Trait::Same => same(arguments),
Trait::Unseen | Trait::Unknown => None,
}
}
enum Shape<'a> {
Pointer,
Reference {
rvalue: bool,
},
Array(bool),
Function,
Builtin(&'a str),
Open,
}
impl Shape<'_> {
fn is_pointer(&self) -> Option<bool> {
match self {
Shape::Pointer => Some(true),
Shape::Open => None,
_ => Some(false),
}
}
fn is_reference(&self, rvalue: bool) -> Option<bool> {
match self {
Shape::Reference { rvalue: written } => Some(*written == rvalue),
Shape::Open => None,
_ => Some(false),
}
}
}
fn shape_of(arguments: &[String]) -> Option<Shape<'_>> {
let [only] = arguments else {
return None;
};
Some(shape(only))
}
fn builtin_kind(arguments: &[String], belongs: fn(&str) -> bool) -> Option<bool> {
match shape_of(arguments)? {
Shape::Builtin(name) => Some(belongs(name)),
Shape::Open => None,
_ => Some(false),
}
}
fn same(arguments: &[String]) -> Option<bool> {
let [left, right] = arguments else {
return None;
};
let (left_type, right_type) = (
crate::sema::types::parse_type_spelling(left),
crate::sema::types::parse_type_spelling(right),
);
if left_type == right_type {
return Some(true);
}
match (shape(left), shape(right)) {
(Shape::Builtin(one), Shape::Builtin(other)) => Some(one == other),
(Shape::Builtin(_), other) | (other, Shape::Builtin(_))
if !matches!(other, Shape::Open) =>
{
Some(false)
}
_ => None,
}
}
fn shape(written: &str) -> Shape<'_> {
let written = written.trim();
match crate::sema::types::parse_type_spelling(written) {
crate::sema::types::Type::Pointer { .. } => Shape::Pointer,
crate::sema::types::Type::Reference { rvalue, .. } => Shape::Reference { rvalue },
crate::sema::types::Type::Array { extent, .. } => Shape::Array(extent.is_some()),
crate::sema::types::Type::Function { .. } => Shape::Function,
crate::sema::types::Type::Builtin { .. } => Shape::Builtin(written),
_ => Shape::Open,
}
}
fn is_an_integral_spelling(name: &str) -> bool {
let name = name.trim();
const INTEGRAL: &[&str] = &[
"bool",
"char",
"signed char",
"unsigned char",
"wchar_t",
"char8_t",
"char16_t",
"char32_t",
"short",
"short int",
"unsigned short",
"unsigned short int",
"int",
"signed",
"signed int",
"unsigned",
"unsigned int",
"long",
"long int",
"unsigned long",
"unsigned long int",
"long long",
"long long int",
"unsigned long long",
"unsigned long long int",
"__int8",
"__int16",
"__int32",
"__int64",
"unsigned __int8",
"unsigned __int16",
"unsigned __int32",
"unsigned __int64",
"__wchar_t",
];
INTEGRAL.contains(&name)
}
fn is_a_floating_spelling(name: &str) -> bool {
let name = name.trim();
matches!(name, "float" | "double" | "long double")
}
pub fn answer_for(name: &str) -> Option<Answer> {
let builtin = named(name)?;
Some(match builtin.kind {
Kind::Trait(_) => Answer::UndecidedBoolean,
_ => Answer::Unmodelled,
})
}
#[cfg(test)]
mod tests {
use super::*;
fn decided(question: Trait, arguments: &[&str]) -> Option<bool> {
let arguments: Vec<String> = arguments.iter().map(|one| one.to_string()).collect();
decide(question, &arguments)
}
#[test]
fn a_pointer_is_decided_by_its_shape_and_not_by_what_it_points_at() {
assert_eq!(decided(Trait::Pointer, &["int*"]), Some(true));
assert_eq!(decided(Trait::Pointer, &["int"]), Some(false));
assert_eq!(decided(Trait::Pointer, &["int[4]"]), Some(false));
assert_eq!(decided(Trait::Pointer, &["_Ty"]), None);
assert_eq!(decided(Trait::Pointer, &["Widget"]), None);
}
#[test]
fn the_reference_questions_tell_the_two_kinds_apart() {
assert_eq!(decided(Trait::LvalueReference, &["int&"]), Some(true));
assert_eq!(decided(Trait::LvalueReference, &["int&&"]), Some(false));
assert_eq!(decided(Trait::RvalueReference, &["int&&"]), Some(true));
assert_eq!(decided(Trait::Reference, &["int&&"]), Some(true));
assert_eq!(decided(Trait::Reference, &["int"]), Some(false));
}
#[test]
fn an_array_answers_the_bound_question_as_well_as_the_array_one() {
assert_eq!(
decided(Trait::Array(ArrayBound::Either), &["int[4]"]),
Some(true)
);
assert_eq!(
decided(Trait::Array(ArrayBound::Bounded), &["int[4]"]),
Some(true)
);
assert_eq!(
decided(Trait::Array(ArrayBound::Bounded), &["int[]"]),
Some(false)
);
assert_eq!(
decided(Trait::Array(ArrayBound::Unbounded), &["int[]"]),
Some(true)
);
assert_eq!(
decided(Trait::Array(ArrayBound::Either), &["int"]),
Some(false)
);
assert_eq!(decided(Trait::Array(ArrayBound::Either), &["_Ty"]), None);
}
#[test]
fn a_builtin_is_its_own_answer_and_a_name_is_not_one() {
assert_eq!(decided(Trait::Void, &["void"]), Some(true));
assert_eq!(decided(Trait::Void, &["int"]), Some(false));
assert_eq!(
decided(Trait::Integral, &["unsigned long long"]),
Some(true)
);
assert_eq!(decided(Trait::Integral, &["double"]), Some(false));
assert_eq!(decided(Trait::FloatingPoint, &["double"]), Some(true));
assert_eq!(decided(Trait::FloatingPoint, &["int"]), Some(false));
assert_eq!(decided(Trait::Integral, &["size_type"]), None);
}
#[test]
fn sameness_is_answered_only_when_the_shapes_settle_it() {
assert_eq!(decided(Trait::Same, &["int", "int"]), Some(true));
assert_eq!(
decided(Trait::Same, &["vector<int>", "vector<int>"]),
Some(true)
);
assert_eq!(decided(Trait::Same, &["int", "double"]), Some(false));
assert_eq!(decided(Trait::Same, &["int", "int*"]), Some(false));
assert_eq!(decided(Trait::Same, &["int", "size_type"]), None);
assert_eq!(decided(Trait::Same, &["_Ty", "_Uty"]), None);
}
#[test]
fn a_question_about_a_class_body_is_left_open() {
assert_eq!(decided(Trait::Unknown, &["_Ty", "_Uty"]), None);
assert_eq!(decided(Trait::Unseen, &["_Ty"]), None);
assert_eq!(decided(Trait::Pointer, &["int", "double"]), None);
assert_eq!(decided(Trait::Same, &["int"]), None);
}
#[test]
fn the_names_the_headers_write_are_the_names_this_knows() {
assert_eq!(
named("__is_constructible").map(|builtin| builtin.kind),
Some(Kind::Trait(Trait::Unknown))
);
assert_eq!(
named("__is_pointer").map(|builtin| builtin.kind),
Some(Kind::Trait(Trait::Pointer))
);
assert!(named("printf").is_none());
assert!(named("is_same").is_none());
assert!(named("is_pointer").is_none());
assert!(named("__is_same").is_some());
}
}