Source code
Revision control
Copy as Markdown
Other Tools
//! Primitives types that can cross the FFI boundary.
use crate::ast;
/// 8, 16, 32, and 64-bit signed and unsigned integers.
#[derive(Copy, Clone, Debug)]
#[allow(clippy::exhaustive_enums)] // there are only these
pub enum IntType {
I8,
I16,
I32,
I64,
U8,
U16,
U32,
U64,
}
/// Platform-dependent signed and unsigned size types.
#[derive(Copy, Clone, Debug)]
#[allow(clippy::exhaustive_enums)] // there are only these
pub enum IntSizeType {
Isize,
Usize,
}
/// 128-bit signed and unsigned integers.
#[derive(Copy, Clone, Debug)]
#[allow(clippy::exhaustive_enums)] // there are only these
pub enum Int128Type {
I128,
U128,
}
/// 32 and 64-bit floating point numbers.
#[derive(Copy, Clone, Debug)]
#[allow(clippy::exhaustive_enums)] // there are only these
pub enum FloatType {
F32,
F64,
}
/// All primitive types.
#[derive(Copy, Clone, Debug)]
#[allow(clippy::exhaustive_enums)] // there are only these
pub enum PrimitiveType {
Bool,
Char,
/// a primitive byte that is not meant to be interpreted numerically
/// in languages that don't have fine-grained integer types
Byte,
Int(IntType),
IntSize(IntSizeType),
Int128(Int128Type),
Float(FloatType),
}
impl IntType {
/// Returns the string representation of `self`.
pub fn as_str(&self) -> &'static str {
match self {
IntType::I8 => "i8",
IntType::I16 => "i16",
IntType::I32 => "i32",
IntType::I64 => "i64",
IntType::U8 => "u8",
IntType::U16 => "u16",
IntType::U32 => "u32",
IntType::U64 => "u64",
}
}
}
impl IntSizeType {
/// Returns the string representation of `self`.
pub fn as_str(&self) -> &'static str {
match self {
IntSizeType::Isize => "isize",
IntSizeType::Usize => "usize",
}
}
}
impl Int128Type {
/// Returns the string representation of `self`.
pub fn as_str(&self) -> &'static str {
match self {
Int128Type::I128 => "i128",
Int128Type::U128 => "u128",
}
}
}
impl FloatType {
/// Returns the string representation of `self`.
pub fn as_str(&self) -> &'static str {
match self {
FloatType::F32 => "f32",
FloatType::F64 => "f64",
}
}
}
impl PrimitiveType {
pub(super) fn from_ast(prim: ast::PrimitiveType) -> Self {
match prim {
ast::PrimitiveType::i8 => PrimitiveType::Int(IntType::I8),
ast::PrimitiveType::u8 => PrimitiveType::Int(IntType::U8),
ast::PrimitiveType::i16 => PrimitiveType::Int(IntType::I16),
ast::PrimitiveType::u16 => PrimitiveType::Int(IntType::U16),
ast::PrimitiveType::i32 => PrimitiveType::Int(IntType::I32),
ast::PrimitiveType::u32 => PrimitiveType::Int(IntType::U32),
ast::PrimitiveType::i64 => PrimitiveType::Int(IntType::I64),
ast::PrimitiveType::u64 => PrimitiveType::Int(IntType::U64),
ast::PrimitiveType::isize => PrimitiveType::IntSize(IntSizeType::Isize),
ast::PrimitiveType::usize => PrimitiveType::IntSize(IntSizeType::Usize),
ast::PrimitiveType::i128 => PrimitiveType::Int128(Int128Type::I128),
ast::PrimitiveType::u128 => PrimitiveType::Int128(Int128Type::U128),
ast::PrimitiveType::f32 => PrimitiveType::Float(FloatType::F32),
ast::PrimitiveType::f64 => PrimitiveType::Float(FloatType::F64),
ast::PrimitiveType::bool => PrimitiveType::Bool,
ast::PrimitiveType::char => PrimitiveType::Char,
ast::PrimitiveType::byte => PrimitiveType::Byte,
}
}
/// Returns the string representation of `self`.
pub fn as_str(&self) -> &'static str {
match self {
PrimitiveType::Bool => "bool",
PrimitiveType::Char => "char",
PrimitiveType::Byte => "byte",
PrimitiveType::Int(ty) => ty.as_str(),
PrimitiveType::IntSize(ty) => ty.as_str(),
PrimitiveType::Int128(ty) => ty.as_str(),
PrimitiveType::Float(ty) => ty.as_str(),
}
}
}