cranelift_codegen_meta/shared/
types.rs

1//! This module predefines all the Cranelift scalar types.
2
3#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
4pub(crate) enum Int {
5    /// 8-bit int.
6    I8 = 8,
7    /// 16-bit int.
8    I16 = 16,
9    /// 32-bit int.
10    I32 = 32,
11    /// 64-bit int.
12    I64 = 64,
13    /// 128-bit int.
14    I128 = 128,
15}
16
17/// This provides an iterator through all of the supported int variants.
18pub(crate) struct IntIterator {
19    index: u8,
20}
21
22impl IntIterator {
23    pub fn new() -> Self {
24        Self { index: 0 }
25    }
26}
27
28impl Iterator for IntIterator {
29    type Item = Int;
30    fn next(&mut self) -> Option<Self::Item> {
31        let res = match self.index {
32            0 => Some(Int::I8),
33            1 => Some(Int::I16),
34            2 => Some(Int::I32),
35            3 => Some(Int::I64),
36            4 => Some(Int::I128),
37            _ => return None,
38        };
39        self.index += 1;
40        res
41    }
42}
43
44#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
45pub(crate) enum Float {
46    F16 = 16,
47    F32 = 32,
48    F64 = 64,
49    F128 = 128,
50}
51
52/// Iterator through the variants of the Float enum.
53pub(crate) struct FloatIterator {
54    index: u8,
55}
56
57impl FloatIterator {
58    pub fn new() -> Self {
59        Self { index: 0 }
60    }
61}
62
63/// This provides an iterator through all of the supported float variants.
64impl Iterator for FloatIterator {
65    type Item = Float;
66    fn next(&mut self) -> Option<Self::Item> {
67        let res = match self.index {
68            0 => Some(Float::F16),
69            1 => Some(Float::F32),
70            2 => Some(Float::F64),
71            3 => Some(Float::F128),
72            _ => return None,
73        };
74        self.index += 1;
75        res
76    }
77}
78
79#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
80pub(crate) enum Reference {
81    /// 32-bit reference.
82    R32 = 32,
83    /// 64-bit reference.
84    R64 = 64,
85}
86
87/// This provides an iterator through all of the supported reference variants.
88pub(crate) struct ReferenceIterator {
89    index: u8,
90}
91
92impl ReferenceIterator {
93    pub fn new() -> Self {
94        Self { index: 0 }
95    }
96}
97
98impl Iterator for ReferenceIterator {
99    type Item = Reference;
100    fn next(&mut self) -> Option<Self::Item> {
101        let res = match self.index {
102            0 => Some(Reference::R32),
103            1 => Some(Reference::R64),
104            _ => return None,
105        };
106        self.index += 1;
107        res
108    }
109}
110
111#[cfg(test)]
112mod iter_tests {
113    use super::*;
114
115    #[test]
116    fn int_iter_works() {
117        let mut int_iter = IntIterator::new();
118        assert_eq!(int_iter.next(), Some(Int::I8));
119        assert_eq!(int_iter.next(), Some(Int::I16));
120        assert_eq!(int_iter.next(), Some(Int::I32));
121        assert_eq!(int_iter.next(), Some(Int::I64));
122        assert_eq!(int_iter.next(), Some(Int::I128));
123        assert_eq!(int_iter.next(), None);
124    }
125
126    #[test]
127    fn float_iter_works() {
128        let mut float_iter = FloatIterator::new();
129        assert_eq!(float_iter.next(), Some(Float::F16));
130        assert_eq!(float_iter.next(), Some(Float::F32));
131        assert_eq!(float_iter.next(), Some(Float::F64));
132        assert_eq!(float_iter.next(), Some(Float::F128));
133        assert_eq!(float_iter.next(), None);
134    }
135
136    #[test]
137    fn reference_iter_works() {
138        let mut reference_iter = ReferenceIterator::new();
139        assert_eq!(reference_iter.next(), Some(Reference::R32));
140        assert_eq!(reference_iter.next(), Some(Reference::R64));
141        assert_eq!(reference_iter.next(), None);
142    }
143}
cranelift_codegen_meta/shared/types.rs

cranelift_codegen_meta/shared/
types.rs
