formalang 0.0.3-beta

FormaLang compiler frontend: lexer, parser, semantic analyzer, and IR lowering.
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
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

//! Inherent accessors on [`IrExpr`]: type lookup and structural
//! predicates.
//!
//! Split out of [`super`] to keep `expr/mod.rs` under the 500-LOC
//! ceiling. The variant definitions live in `expr/mod.rs`; the
//! per-variant operations live here.

use super::IrExpr;
use crate::ir::ResolvedType;

impl IrExpr {
    /// Get the resolved type of this expression.
    #[must_use]
    pub const fn ty(&self) -> &ResolvedType {
        match self {
            Self::Literal { ty, .. }
            | Self::StructInst { ty, .. }
            | Self::EnumInst { ty, .. }
            | Self::Array { ty, .. }
            | Self::Tuple { ty, .. }
            | Self::Reference { ty, .. }
            | Self::SelfFieldRef { ty, .. }
            | Self::FieldAccess { ty, .. }
            | Self::LetRef { ty, .. }
            | Self::BinaryOp { ty, .. }
            | Self::UnaryOp { ty, .. }
            | Self::If { ty, .. }
            | Self::For { ty, .. }
            | Self::Match { ty, .. }
            | Self::FunctionCall { ty, .. }
            | Self::CallClosure { ty, .. }
            | Self::MethodCall { ty, .. }
            | Self::Closure { ty, .. }
            | Self::ClosureRef { ty, .. }
            | Self::DictLiteral { ty, .. }
            | Self::DictAccess { ty, .. }
            | Self::Block { ty, .. } => ty,
        }
    }

    /// Get a mutable reference to the resolved type of this expression.
    pub const fn ty_mut(&mut self) -> &mut ResolvedType {
        match self {
            Self::Literal { ty, .. }
            | Self::StructInst { ty, .. }
            | Self::EnumInst { ty, .. }
            | Self::Array { ty, .. }
            | Self::Tuple { ty, .. }
            | Self::Reference { ty, .. }
            | Self::SelfFieldRef { ty, .. }
            | Self::FieldAccess { ty, .. }
            | Self::LetRef { ty, .. }
            | Self::BinaryOp { ty, .. }
            | Self::UnaryOp { ty, .. }
            | Self::If { ty, .. }
            | Self::For { ty, .. }
            | Self::Match { ty, .. }
            | Self::FunctionCall { ty, .. }
            | Self::CallClosure { ty, .. }
            | Self::MethodCall { ty, .. }
            | Self::Closure { ty, .. }
            | Self::ClosureRef { ty, .. }
            | Self::DictLiteral { ty, .. }
            | Self::DictAccess { ty, .. }
            | Self::Block { ty, .. } => ty,
        }
    }

    /// Get a mutable reference to the source span of this expression.
    pub const fn span_mut(&mut self) -> &mut crate::ir::IrSpan {
        match self {
            Self::Literal { span, .. }
            | Self::StructInst { span, .. }
            | Self::EnumInst { span, .. }
            | Self::Array { span, .. }
            | Self::Tuple { span, .. }
            | Self::Reference { span, .. }
            | Self::SelfFieldRef { span, .. }
            | Self::FieldAccess { span, .. }
            | Self::LetRef { span, .. }
            | Self::BinaryOp { span, .. }
            | Self::UnaryOp { span, .. }
            | Self::If { span, .. }
            | Self::For { span, .. }
            | Self::Match { span, .. }
            | Self::FunctionCall { span, .. }
            | Self::CallClosure { span, .. }
            | Self::MethodCall { span, .. }
            | Self::Closure { span, .. }
            | Self::ClosureRef { span, .. }
            | Self::DictLiteral { span, .. }
            | Self::DictAccess { span, .. }
            | Self::Block { span, .. } => span,
        }
    }

    /// Whether this expression is a constant aggregate — a literal, or an
    /// aggregate (array / tuple / struct / enum / dict) whose every leaf is a
    /// literal. After [`fold_constants`](crate::ir::fold_constants) this
    /// predicate is the load-bearing marker for "static initializer": backends
    /// emitting read-only data segments can short-circuit on it instead of
    /// re-walking children themselves.
    #[must_use]
    pub fn is_constant(&self) -> bool {
        match self {
            Self::Literal { .. } => true,
            Self::Array { elements, .. } => elements.iter().all(Self::is_constant),
            Self::Tuple { fields, .. } => fields.iter().all(|(_, e)| e.is_constant()),
            Self::StructInst { fields, .. } | Self::EnumInst { fields, .. } => {
                fields.iter().all(|(_, _, e)| e.is_constant())
            }
            Self::DictLiteral { entries, .. } => entries
                .iter()
                .all(|(k, v)| k.is_constant() && v.is_constant()),
            Self::Reference { .. }
            | Self::SelfFieldRef { .. }
            | Self::FieldAccess { .. }
            | Self::LetRef { .. }
            | Self::BinaryOp { .. }
            | Self::UnaryOp { .. }
            | Self::If { .. }
            | Self::For { .. }
            | Self::Match { .. }
            | Self::FunctionCall { .. }
            | Self::CallClosure { .. }
            | Self::MethodCall { .. }
            | Self::Closure { .. }
            | Self::ClosureRef { .. }
            | Self::DictAccess { .. }
            | Self::Block { .. } => false,
        }
    }
}