crates/hir_def/src/builtin_type.rs

   1 //! This module defines built-in types.
   2 //!
   3 //! A peculiarity of built-in types is that they are always available and are
   4 //! not associated with any particular crate.
   5
   6 use std::fmt;
   7
   8 use hir_expand::name::{name, AsName, Name};
   9 /// Different signed int types.
  10 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
  11 pub enum BuiltinInt {
  12     Isize,
  13     I8,
  14     I16,
  15     I32,
  16     I64,
  17     I128,
  18 }
  19
  20 /// Different unsigned int types.
  21 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
  22 pub enum BuiltinUint {
  23     Usize,
  24     U8,
  25     U16,
  26     U32,
  27     U64,
  28     U128,
  29 }
  30
  31 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
  32 pub enum BuiltinFloat {
  33     F32,
  34     F64,
  35 }
  36
  37 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  38 pub enum BuiltinType {
  39     Char,
  40     Bool,
  41     Str,
  42     Int(BuiltinInt),
  43     Uint(BuiltinUint),
  44     Float(BuiltinFloat),
  45 }
  46
  47 impl BuiltinType {
  48     #[rustfmt::skip]
  49     pub const ALL: &'static [(Name, BuiltinType)] = &[
  50         (name![char], BuiltinType::Char),
  51         (name![bool], BuiltinType::Bool),
  52         (name![str],  BuiltinType::Str),
  53
  54         (name![isize], BuiltinType::Int(BuiltinInt::Isize)),
  55         (name![i8],    BuiltinType::Int(BuiltinInt::I8)),
  56         (name![i16],   BuiltinType::Int(BuiltinInt::I16)),
  57         (name![i32],   BuiltinType::Int(BuiltinInt::I32)),
  58         (name![i64],   BuiltinType::Int(BuiltinInt::I64)),
  59         (name![i128],  BuiltinType::Int(BuiltinInt::I128)),
  60
  61         (name![usize], BuiltinType::Uint(BuiltinUint::Usize)),
  62         (name![u8],    BuiltinType::Uint(BuiltinUint::U8)),
  63         (name![u16],   BuiltinType::Uint(BuiltinUint::U16)),
  64         (name![u32],   BuiltinType::Uint(BuiltinUint::U32)),
  65         (name![u64],   BuiltinType::Uint(BuiltinUint::U64)),
  66         (name![u128],  BuiltinType::Uint(BuiltinUint::U128)),
  67
  68         (name![f32], BuiltinType::Float(BuiltinFloat::F32)),
  69         (name![f64], BuiltinType::Float(BuiltinFloat::F64)),
  70     ];
  71 }
  72
  73 impl AsName for BuiltinType {
  74     fn as_name(&self) -> Name {
  75         match self {
  76             BuiltinType::Char => name![char],
  77             BuiltinType::Bool => name![bool],
  78             BuiltinType::Str => name![str],
  79             BuiltinType::Int(it) => match it {
  80                 BuiltinInt::Isize => name![isize],
  81                 BuiltinInt::I8 => name![i8],
  82                 BuiltinInt::I16 => name![i16],
  83                 BuiltinInt::I32 => name![i32],
  84                 BuiltinInt::I64 => name![i64],
  85                 BuiltinInt::I128 => name![i128],
  86             },
  87             BuiltinType::Uint(it) => match it {
  88                 BuiltinUint::Usize => name![usize],
  89                 BuiltinUint::U8 => name![u8],
  90                 BuiltinUint::U16 => name![u16],
  91                 BuiltinUint::U32 => name![u32],
  92                 BuiltinUint::U64 => name![u64],
  93                 BuiltinUint::U128 => name![u128],
  94             },
  95             BuiltinType::Float(it) => match it {
  96                 BuiltinFloat::F32 => name![f32],
  97                 BuiltinFloat::F64 => name![f64],
  98             },
  99         }
 100     }
 101 }
 102
 103 impl fmt::Display for BuiltinType {
 104     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 105         let type_name = self.as_name();
 106         type_name.fmt(f)
 107     }
 108 }
 109
 110 #[rustfmt::skip]
 111 impl BuiltinInt {
 112     pub fn from_suffix(suffix: &str) -> Option<BuiltinInt> {
 113         let res = match suffix {
 114             "isize" => Self::Isize,
 115             "i8"    => Self::I8,
 116             "i16"   => Self::I16,
 117             "i32"   => Self::I32,
 118             "i64"   => Self::I64,
 119             "i128"  => Self::I128,
 120
 121             _ => return None,
 122         };
 123         Some(res)
 124     }
 125 }
 126
 127 #[rustfmt::skip]
 128 impl BuiltinUint {
 129     pub fn from_suffix(suffix: &str) -> Option<BuiltinUint> {
 130         let res = match suffix {
 131             "usize" => Self::Usize,
 132             "u8"    => Self::U8,
 133             "u16"   => Self::U16,
 134             "u32"   => Self::U32,
 135             "u64"   => Self::U64,
 136             "u128"  => Self::U128,
 137
 138             _ => return None,
 139         };
 140         Some(res)
 141     }
 142 }
 143
 144 #[rustfmt::skip]
 145 impl BuiltinFloat {
 146     pub fn from_suffix(suffix: &str) -> Option<BuiltinFloat> {
 147         let res = match suffix {
 148             "f32" => BuiltinFloat::F32,
 149             "f64" => BuiltinFloat::F64,
 150             _ => return None,
 151         };
 152         Some(res)
 153     }
 154 }