rue-compiler 0.8.4

A compiler for the Rue programming language.
Documentation 
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

use std::borrow::Cow;

use log::debug;
use rue_ast::{AstExpr, AstNode, AstPrefixExpr};
use rue_diagnostic::DiagnosticKind;
use rue_hir::{Hir, UnaryOp, Value};
use rue_lir::{atom_bigint, bigint_atom};
use rue_parser::T;
use rue_types::{Atom, AtomRestriction, AtomSemantic, Atoms, Type};

use crate::{Compiler, compile_expr};

pub fn compile_prefix_expr(ctx: &mut Compiler, prefix: &AstPrefixExpr) -> Value {
    let Some(expr) = prefix.expr() else {
        debug!("Unresolved prefix expr");
        return ctx.builtins().unresolved.clone();
    };

    let value = compile_expr(ctx, &expr, None);

    if ctx.is_unresolved(value.ty) {
        debug!("Unresolved prefix expr");
        return ctx.builtins().unresolved.clone();
    }

    let Some(op) = prefix.op() else {
        return value;
    };

    match op.kind() {
        T![!] => {
            if ctx.is_assignable(value.ty, ctx.builtins().types.bool) {
                let is_true = ctx.is_assignable(value.ty, ctx.builtins().types.bool_true);
                let is_false = ctx.is_assignable(value.ty, ctx.builtins().types.bool_false);

                let hir = ctx.alloc_hir(Hir::Unary(UnaryOp::Not, value.hir));

                return value.flip_mappings().with_hir(hir).with_type(if is_true {
                    ctx.builtins().types.bool_false
                } else if is_false {
                    ctx.builtins().types.bool_true
                } else {
                    ctx.builtins().types.bool
                });
            }
        }
        T![+] => {
            if ctx.is_assignable(value.ty, ctx.builtins().types.int) {
                ctx.diagnostic(prefix.syntax(), DiagnosticKind::UnnecessaryPlus);
                return Value::new(value.hir, ctx.builtins().types.int);
            }
        }
        T![-] => {
            if let AstExpr::PrefixExpr(inner) = &expr
                && let Some(op) = inner.op()
                && op.kind() == T![-]
            {
                ctx.diagnostic(prefix.syntax(), DiagnosticKind::DoubleNegationWarning);
            }

            if ctx.is_assignable(value.ty, ctx.builtins().types.int) {
                let ty = if let Some(Atoms::Restricted(restrictions)) =
                    rue_types::extract_atoms(ctx.types_mut(), value.ty, true)
                    && restrictions.len() == 1
                    && let Some(AtomRestriction::Value(value)) = restrictions.iter().next()
                {
                    ctx.alloc_type(Type::Atom(Atom::new(
                        AtomSemantic::Int,
                        Some(AtomRestriction::Value(Cow::Owned(bigint_atom(
                            -atom_bigint(value),
                        )))),
                    )))
                } else {
                    ctx.builtins().types.int
                };

                let hir = ctx.alloc_hir(Hir::Unary(UnaryOp::Neg, value.hir));
                return Value::new(hir, ty);
            }

            if ctx.is_assignable(value.ty, ctx.builtins().types.public_key) {
                let hir = ctx.alloc_hir(Hir::Unary(UnaryOp::G1Negate, value.hir));
                return Value::new(hir, ctx.builtins().types.public_key);
            }

            if ctx.is_assignable(value.ty, ctx.builtins().types.signature) {
                let hir = ctx.alloc_hir(Hir::Unary(UnaryOp::G2Negate, value.hir));
                return Value::new(hir, ctx.builtins().types.signature);
            }
        }
        T![~] => {
            if ctx.is_assignable(value.ty, ctx.builtins().types.int) {
                let hir = ctx.alloc_hir(Hir::Unary(UnaryOp::BitwiseNot, value.hir));
                return Value::new(hir, ctx.builtins().types.int);
            }
        }
        _ => {}
    }

    debug!("Unresolved prefix expr due to incompatible op");

    let type_name = ctx.type_name(value.ty);
    ctx.diagnostic(
        prefix.syntax(),
        DiagnosticKind::IncompatibleUnaryOp(op.text().to_string(), type_name),
    );
    ctx.builtins().unresolved.clone()
}