src/tools/rust-analyzer/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     pub fn by_name(name: &Name) -> Option<Self> {
  73         Self::ALL.iter().find_map(|(n, ty)| if n == name { Some(*ty) } else { None })
  74     }
  75 }
  76
  77 impl AsName for BuiltinType {
  78     fn as_name(&self) -> Name {
  79         match self {
  80             BuiltinType::Char => name![char],
  81             BuiltinType::Bool => name![bool],
  82             BuiltinType::Str => name![str],
  83             BuiltinType::Int(it) => match it {
  84                 BuiltinInt::Isize => name![isize],
  85                 BuiltinInt::I8 => name![i8],
  86                 BuiltinInt::I16 => name![i16],
  87                 BuiltinInt::I32 => name![i32],
  88                 BuiltinInt::I64 => name![i64],
  89                 BuiltinInt::I128 => name![i128],
  90             },
  91             BuiltinType::Uint(it) => match it {
  92                 BuiltinUint::Usize => name![usize],
  93                 BuiltinUint::U8 => name![u8],
  94                 BuiltinUint::U16 => name![u16],
  95                 BuiltinUint::U32 => name![u32],
  96                 BuiltinUint::U64 => name![u64],
  97                 BuiltinUint::U128 => name![u128],
  98             },
  99             BuiltinType::Float(it) => match it {
 100                 BuiltinFloat::F32 => name![f32],
 101                 BuiltinFloat::F64 => name![f64],
 102             },
 103         }
 104     }
 105 }
 106
 107 impl fmt::Display for BuiltinType {
 108     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 109         let type_name = self.as_name();
 110         type_name.fmt(f)
 111     }
 112 }
 113
 114 #[rustfmt::skip]
 115 impl BuiltinInt {
 116     pub fn from_suffix(suffix: &str) -> Option<BuiltinInt> {
 117         let res = match suffix {
 118             "isize" => Self::Isize,
 119             "i8"    => Self::I8,
 120             "i16"   => Self::I16,
 121             "i32"   => Self::I32,
 122             "i64"   => Self::I64,
 123             "i128"  => Self::I128,
 124
 125             _ => return None,
 126         };
 127         Some(res)
 128     }
 129 }
 130
 131 #[rustfmt::skip]
 132 impl BuiltinUint {
 133     pub fn from_suffix(suffix: &str) -> Option<BuiltinUint> {
 134         let res = match suffix {
 135             "usize" => Self::Usize,
 136             "u8"    => Self::U8,
 137             "u16"   => Self::U16,
 138             "u32"   => Self::U32,
 139             "u64"   => Self::U64,
 140             "u128"  => Self::U128,
 141
 142             _ => return None,
 143         };
 144         Some(res)
 145     }
 146 }
 147
 148 #[rustfmt::skip]
 149 impl BuiltinFloat {
 150     pub fn from_suffix(suffix: &str) -> Option<BuiltinFloat> {
 151         let res = match suffix {
 152             "f32" => BuiltinFloat::F32,
 153             "f64" => BuiltinFloat::F64,
 154             _ => return None,
 155         };
 156         Some(res)
 157     }
 158 }
 159
 160 impl fmt::Display for BuiltinInt {
 161     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 162         f.write_str(match self {
 163             BuiltinInt::Isize => "isize",
 164             BuiltinInt::I8 => "i8",
 165             BuiltinInt::I16 => "i16",
 166             BuiltinInt::I32 => "i32",
 167             BuiltinInt::I64 => "i64",
 168             BuiltinInt::I128 => "i128",
 169         })
 170     }
 171 }
 172
 173 impl fmt::Display for BuiltinUint {
 174     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 175         f.write_str(match self {
 176             BuiltinUint::Usize => "usize",
 177             BuiltinUint::U8 => "u8",
 178             BuiltinUint::U16 => "u16",
 179             BuiltinUint::U32 => "u32",
 180             BuiltinUint::U64 => "u64",
 181             BuiltinUint::U128 => "u128",
 182         })
 183     }
 184 }
 185
 186 impl fmt::Display for BuiltinFloat {
 187     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 188         f.write_str(match self {
 189             BuiltinFloat::F32 => "f32",
 190             BuiltinFloat::F64 => "f64",
 191         })
 192     }
 193 }