Skip to main content

rue_types/
builtins.rs

1use id_arena::Arena;
2use rue_diagnostic::Name;
3
4use crate::{Alias, Atom, Generic, Pair, Type, TypeId, Union};
5
6#[derive(Debug, Clone, Copy)]
7pub struct BuiltinTypes {
8    pub unresolved: TypeId,
9    pub atom: TypeId,
10    pub bytes: TypeId,
11    pub bytes32: TypeId,
12    pub string: TypeId,
13    pub public_key: TypeId,
14    pub signature: TypeId,
15    pub k1_public_key: TypeId,
16    pub k1_signature: TypeId,
17    pub r1_public_key: TypeId,
18    pub r1_signature: TypeId,
19    pub int: TypeId,
20    pub bool_true: TypeId,
21    pub bool_false: TypeId,
22    pub bool: TypeId,
23    pub nil: TypeId,
24    pub never: TypeId,
25    pub recursive_any: TypeId,
26    pub recursive_any_pair: TypeId,
27    pub permissive_any: TypeId,
28    pub list: TypeId,
29    pub list_generic: TypeId,
30    pub alternating_list: TypeId,
31    pub alternating_list_generic_a: TypeId,
32    pub alternating_list_generic_b: TypeId,
33}
34
35impl BuiltinTypes {
36    pub fn new(arena: &mut Arena<Type>) -> Self {
37        let unresolved = arena.alloc(Type::Unresolved);
38        let atom = arena.alloc(Type::Atom(Atom::ANY));
39        let bytes = arena.alloc(Type::Atom(Atom::BYTES));
40        let bytes32 = arena.alloc(Type::Atom(Atom::BYTES_32));
41        let string = arena.alloc(Type::Atom(Atom::STRING));
42        let public_key = arena.alloc(Type::Atom(Atom::PUBLIC_KEY));
43        let signature = arena.alloc(Type::Atom(Atom::SIGNATURE));
44        let k1_public_key = arena.alloc(Type::Atom(Atom::K1_PUBLIC_KEY));
45        let k1_signature = arena.alloc(Type::Atom(Atom::K1_SIGNATURE));
46        let r1_public_key = arena.alloc(Type::Atom(Atom::R1_PUBLIC_KEY));
47        let r1_signature = arena.alloc(Type::Atom(Atom::R1_SIGNATURE));
48        let int = arena.alloc(Type::Atom(Atom::INT));
49        let bool_true = arena.alloc(Type::Atom(Atom::TRUE));
50        let bool_false = arena.alloc(Type::Atom(Atom::FALSE));
51        let bool = arena.alloc(Type::Union(Union::new(vec![bool_true, bool_false])));
52        let never = arena.alloc(Type::Never);
53        let nil = arena.alloc(Type::Atom(Atom::NIL));
54
55        let recursive_any = arena.alloc(Type::Unresolved);
56        let recursive_any_pair = arena.alloc(Type::Pair(Pair::new(recursive_any, recursive_any)));
57        *arena.get_mut(recursive_any).unwrap() =
58            Type::Union(Union::new(vec![atom, recursive_any_pair]));
59        let permissive_any = arena.alloc(Type::Any);
60
61        let list = arena.alloc(Type::Unresolved);
62        let list_generic = arena.alloc(Type::Generic(Generic {
63            name: Some(Name::new("T", None)),
64        }));
65        let list_pair = arena.alloc(Type::Pair(Pair::new(list_generic, list)));
66        let list_union = arena.alloc(Type::Union(Union::new(vec![nil, list_pair])));
67        *arena.get_mut(list).unwrap() = Type::Alias(Alias {
68            name: Some(Name::new("List", None)),
69            inner: list_union,
70            generics: vec![list_generic],
71        });
72
73        let alternating_list = arena.alloc(Type::Unresolved);
74        let alternating_list_generic_a = arena.alloc(Type::Generic(Generic {
75            name: Some(Name::new("A", None)),
76        }));
77        let alternating_list_generic_b = arena.alloc(Type::Generic(Generic {
78            name: Some(Name::new("B", None)),
79        }));
80        let alternating_list_pair = arena.alloc(Type::Pair(Pair::new(
81            alternating_list_generic_b,
82            alternating_list,
83        )));
84        let alternating_list_pair = arena.alloc(Type::Pair(Pair::new(
85            alternating_list_generic_a,
86            alternating_list_pair,
87        )));
88        let alternating_list_union =
89            arena.alloc(Type::Union(Union::new(vec![nil, alternating_list_pair])));
90        *arena.get_mut(alternating_list).unwrap() = Type::Alias(Alias {
91            name: Some(Name::new("AlternatingList", None)),
92            inner: alternating_list_union,
93            generics: vec![alternating_list_generic_a, alternating_list_generic_b],
94        });
95
96        Self {
97            unresolved,
98            atom,
99            bytes,
100            bytes32,
101            string,
102            public_key,
103            signature,
104            k1_public_key,
105            k1_signature,
106            r1_public_key,
107            r1_signature,
108            int,
109            bool_true,
110            bool_false,
111            bool,
112            nil,
113            never,
114            recursive_any,
115            recursive_any_pair,
116            permissive_any,
117            list,
118            list_generic,
119            alternating_list,
120            alternating_list_generic_a,
121            alternating_list_generic_b,
122        }
123    }
124}