mathic 0.2.0

A compiler with builtin support of symbolic operations, built with LLVM/MLIR
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::{
    diagnostics::LoweringError,
    lowering::{
        ast_lowering::{expression, statement},
        ir::{
            adts::{Adt, StructAdt, StructField},
            function::{FunctionBuilder, LocalKind},
            instruction::LValInstruct,
            types::{MathicType, lower_inner_ast_type},
        },
    },
    parser::{
        Span,
        ast::{
            declaration::{DeclStmt, FuncDecl, StructDecl, SymDecl, VarDecl},
            statement::StmtKind,
        },
    },
};

pub fn lower_var_declaration(
    func: &mut FunctionBuilder,
    stmt: &VarDecl,
    span: Span,
) -> Result<(), LoweringError> {
    let VarDecl {
        name,
        expr,
        ty: var_ty,
    } = stmt;
    let var_ty_idx = lower_inner_ast_type(func, var_ty, span)?;
    let (init, expr_ty_idx) = expression::lower_expr(func, expr, Some(var_ty_idx))?;

    let var_ty = func.get_type(var_ty_idx, span)?;
    let expr_ty = func.get_type(expr_ty_idx, span)?;

    if expr_ty_idx != var_ty_idx {
        return Err(LoweringError::MismatchedType {
            expected: var_ty,
            found: expr_ty,
            span,
        });
    }

    let local_idx =
        func.sym_table
            .add_local(Some(name.clone()), var_ty_idx, Some(span), LocalKind::Temp)?;

    func.push_instruction(LValInstruct::Let {
        local_idx,
        init,
        span: Some(span),
    });

    Ok(())
}

pub fn lower_sym_decl(
    func: &mut FunctionBuilder,
    sym_decl: &SymDecl,
    span: Span,
) -> Result<(), LoweringError> {
    let SymDecl { name, ty } = sym_decl;

    let sym_ty_idx = lower_inner_ast_type(func, ty, span)?;
    let local_idx =
        func.sym_table
            .add_local(Some(name.clone()), sym_ty_idx, Some(span), LocalKind::Sym)?;

    func.push_instruction(LValInstruct::Sym {
        local_idx,
        sym_name: name.clone(),
        ty: sym_ty_idx,
        span: Some(span),
    });

    Ok(())
}

pub fn lower_inner_struct(
    func: &mut FunctionBuilder,
    struct_decl: &StructDecl,
) -> Result<usize, LoweringError> {
    let StructDecl { name, fields, span } = struct_decl;

    let mut adt = StructAdt {
        name: name.clone(),
        fields: Vec::new(),
        _span: *span,
    };

    for field in fields {
        adt.fields.push(StructField {
            name: field.name.clone(),
            ty: lower_inner_ast_type(func, &field.ty, field.span)?,
            _is_pub: field.is_pub,
        });
    }

    let idx = func.add_adt(adt.name.clone(), Adt::Struct(adt));

    Ok(idx)
}

pub fn lower_inner_function(
    func: &mut FunctionBuilder,
    stmt: &FuncDecl,
    span: Span,
) -> Result<(), LoweringError> {
    let FuncDecl {
        name,
        params,
        body,
        return_ty,
        ..
    } = stmt;

    let mut inner_func = FunctionBuilder::new(
        name.clone(),
        params,
        match return_ty {
            Some(ty) => lower_inner_ast_type(func, ty, span)?,
            None => func.get_or_insert_global_type_idx(MathicType::Void),
        },
        func.ir_builder,
        span,
    )?;

    // Save function's declaration. This for on-demand lowering, allowing
    // to reference function no yet declared. For example, a function call
    // of a not yet declared function.
    for stmt in body.iter() {
        match &stmt.kind {
            StmtKind::Decl(DeclStmt::Func(f)) => inner_func.decl_table.add_func_decl(f.clone()),
            StmtKind::Decl(DeclStmt::Struct(f)) => inner_func.decl_table.add_struct_decl(f.clone()),
            _ => {}
        }
    }

    for stmt in body.iter() {
        statement::lower_stmt(&mut inner_func, stmt)?;
    }

    let inner_func = inner_func.build();

    func.sym_table.add_function(inner_func);

    Ok(())
}