1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::sync::Arc;

use crate::{
    codegen::ty::{Adt, CodegenTy},
    symbol::{DefId, Ident, TagId},
};

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Graph {
    pub name: Ident,
    pub entry_node: DefId,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Node {
    pub name: Ident,
    pub to_nodes: Vec<DefId>,
    pub fields: Vec<Arc<Field>>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Field {
    pub name: Ident,
    pub ty: Type,
    pub tag_id: TagId,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub struct Path {
    pub segments: Arc<[Ident]>,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Type {
    String,
    Void,
    U8,
    Bool,
    Bytes,
    I8,
    I16,
    I32,
    I64,
    F64,
    Vec(Arc<Type>),
    Set(Arc<Type>),
    Map(Arc<Type>, Arc<Type>),
    Path(Path),
}

impl Type {
    pub fn to_codegen_ty(&self) -> CodegenTy {
        match self {
            Type::String => CodegenTy::String,
            Type::Void => CodegenTy::Void,
            Type::U8 => CodegenTy::U8,
            Type::Bool => CodegenTy::Bool,
            Type::Bytes => CodegenTy::Bytes,
            Type::I8 => CodegenTy::I8,
            Type::I16 => CodegenTy::I16,
            Type::I32 => CodegenTy::I32,
            Type::I64 => CodegenTy::I64,
            Type::F64 => CodegenTy::F64,
            Type::Vec(ty) => CodegenTy::Vec(Arc::from(ty.to_codegen_ty())),
            Type::Set(ty) => CodegenTy::Set(Arc::from(ty.to_codegen_ty())),
            Type::Map(k, v) => {
                CodegenTy::Map(Arc::from(k.to_codegen_ty()), Arc::from(v.to_codegen_ty()))
            }
            Type::Path(p) => CodegenTy::Adt(Adt {
                segments: p.segments.clone(),
            }),
        }
    }
}