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}