rune/compile/ir/
eval.rs

Help
1use core::ops::{Add, Mul, Shl, Shr, Sub};
2
3use crate::alloc::fmt::TryWrite;
4use crate::alloc::prelude::*;
5use crate::alloc::{Box, String, Vec};
6use crate::ast::{Span, Spanned};
7use crate::compile::ir::{self};
8use crate::compile::{self, WithSpan};
9use crate::query::Used;
10use crate::runtime::{Inline, Object, OwnedTuple, Repr, Value};
11use crate::TypeHash;
12
13/// The outcome of a constant evaluation.
14pub enum EvalOutcome {
15    /// Encountered expression that is not a valid constant expression.
16    NotConst(Span),
17    /// A compile error.
18    Error(compile::Error),
19    /// Break until the next loop, or the optional label.
20    Break(Span, Option<Box<str>>, Option<Value>),
21}
22
23impl EvalOutcome {
24    /// Encountered ast that is not a constant expression.
25    pub(crate) fn not_const<S>(spanned: S) -> Self
26    where
27        S: Spanned,
28    {
29        Self::NotConst(spanned.span())
30    }
31}
32
33impl<T> From<T> for EvalOutcome
34where
35    compile::Error: From<T>,
36{
37    fn from(error: T) -> Self {
38        Self::Error(compile::Error::from(error))
39    }
40}
41
42fn eval_ir_assign(
43    ir: &ir::IrAssign,
44    interp: &mut ir::Interpreter<'_, '_>,
45    used: Used,
46) -> Result<Value, EvalOutcome> {
47    interp.budget.take(ir)?;
48    let value = eval_ir(&ir.value, interp, used)?;
49
50    interp
51        .scopes
52        .mut_target(&ir.target, move |t| ir.op.assign(ir, t, value))?;
53
54    Ok(Value::unit())
55}
56
57fn eval_ir_binary(
58    ir: &ir::IrBinary,
59    interp: &mut ir::Interpreter<'_, '_>,
60    used: Used,
61) -> Result<Value, EvalOutcome> {
62    fn add_strings(a: &str, b: &str) -> crate::alloc::Result<String> {
63        let mut out = String::try_with_capacity(a.len() + b.len())?;
64        out.try_push_str(a)?;
65        out.try_push_str(b)?;
66        Ok(out)
67    }
68
69    let span = ir.span();
70    interp.budget.take(span)?;
71
72    let a = eval_ir(&ir.lhs, interp, used)?;
73    let b = eval_ir(&ir.rhs, interp, used)?;
74
75    let a = a.as_ref();
76    let b = b.as_ref();
77
78    match (a, b) {
79        (Repr::Inline(a), Repr::Inline(b)) => {
80            let out = 'out: {
81                match (a, b) {
82                    (Inline::Signed(a), Inline::Signed(b)) => match ir.op {
83                        ir::IrBinaryOp::Add => {
84                            break 'out Inline::Signed(a.add(b));
85                        }
86                        ir::IrBinaryOp::Sub => {
87                            break 'out Inline::Signed(a.sub(b));
88                        }
89                        ir::IrBinaryOp::Mul => {
90                            break 'out Inline::Signed(a.mul(b));
91                        }
92                        ir::IrBinaryOp::Div => {
93                            let number = a
94                                .checked_div(*b)
95                                .ok_or_else(|| compile::Error::msg(span, "division by zero"))?;
96                            break 'out Inline::Signed(number);
97                        }
98                        ir::IrBinaryOp::Shl => {
99                            let b = u32::try_from(*b).map_err(|_| {
100                                compile::Error::msg(&ir.rhs, "cannot be converted to shift operand")
101                            })?;
102
103                            let n = a.shl(b);
104                            break 'out Inline::Signed(n);
105                        }
106                        ir::IrBinaryOp::Shr => {
107                            let b = u32::try_from(*b).map_err(|_| {
108                                compile::Error::msg(&ir.rhs, "cannot be converted to shift operand")
109                            })?;
110
111                            let n = a.shr(b);
112                            break 'out Inline::Signed(n);
113                        }
114                        ir::IrBinaryOp::Lt => break 'out Inline::Bool(a < b),
115                        ir::IrBinaryOp::Lte => break 'out Inline::Bool(a <= b),
116                        ir::IrBinaryOp::Eq => break 'out Inline::Bool(a == b),
117                        ir::IrBinaryOp::Gt => break 'out Inline::Bool(a > b),
118                        ir::IrBinaryOp::Gte => break 'out Inline::Bool(a >= b),
119                    },
120                    (Inline::Float(a), Inline::Float(b)) => {
121                        #[allow(clippy::float_cmp)]
122                        match ir.op {
123                            ir::IrBinaryOp::Add => break 'out Inline::Float(a + b),
124                            ir::IrBinaryOp::Sub => break 'out Inline::Float(a - b),
125                            ir::IrBinaryOp::Mul => break 'out Inline::Float(a * b),
126                            ir::IrBinaryOp::Div => break 'out Inline::Float(a / b),
127                            ir::IrBinaryOp::Lt => break 'out Inline::Bool(a < b),
128                            ir::IrBinaryOp::Lte => break 'out Inline::Bool(a <= b),
129                            ir::IrBinaryOp::Eq => break 'out Inline::Bool(a == b),
130                            ir::IrBinaryOp::Gt => break 'out Inline::Bool(a > b),
131                            ir::IrBinaryOp::Gte => break 'out Inline::Bool(a >= b),
132                            _ => (),
133                        };
134                    }
135                    _ => {}
136                }
137
138                return Err(EvalOutcome::not_const(span));
139            };
140
141            return Ok(Value::from(out));
142        }
143        (Repr::Any(a), Repr::Any(b)) => {
144            let value = 'out: {
145                if let (String::HASH, String::HASH) = (a.type_hash(), b.type_hash()) {
146                    let a = a.borrow_ref::<String>().with_span(span)?;
147                    let b = b.borrow_ref::<String>().with_span(span)?;
148
149                    if let ir::IrBinaryOp::Add = ir.op {
150                        let string = add_strings(&a, &b).with_span(span)?;
151                        break 'out Value::new(string).with_span(span)?;
152                    }
153                }
154
155                return Err(EvalOutcome::not_const(span));
156            };
157
158            return Ok(value);
159        }
160        _ => (),
161    }
162
163    Err(EvalOutcome::not_const(span))
164}
165
166fn eval_ir_branches(
167    ir: &ir::IrBranches,
168    interp: &mut ir::Interpreter<'_, '_>,
169    used: Used,
170) -> Result<Value, EvalOutcome> {
171    for (ir_condition, branch) in &ir.branches {
172        let guard = interp.scopes.push()?;
173
174        let value = eval_ir_condition(ir_condition, interp, used)?;
175
176        let output = if value.as_bool().with_span(ir_condition)? {
177            Some(eval_ir_scope(branch, interp, used)?)
178        } else {
179            None
180        };
181
182        interp.scopes.pop(guard).with_span(branch)?;
183
184        if let Some(output) = output {
185            return Ok(output);
186        }
187    }
188
189    if let Some(branch) = &ir.default_branch {
190        return eval_ir_scope(branch, interp, used);
191    }
192
193    Ok(Value::unit())
194}
195
196fn eval_ir_call(
197    ir: &ir::IrCall,
198    interp: &mut ir::Interpreter<'_, '_>,
199    used: Used,
200) -> Result<Value, EvalOutcome> {
201    let mut args = Vec::new();
202
203    for arg in &ir.args {
204        args.try_push(eval_ir(arg, interp, used)?)?;
205    }
206
207    Ok(interp.call_const_fn(ir, ir.id, args, used)?)
208}
209
210fn eval_ir_condition(
211    ir: &ir::IrCondition,
212    interp: &mut ir::Interpreter<'_, '_>,
213    used: Used,
214) -> Result<Value, EvalOutcome> {
215    let value = match ir {
216        ir::IrCondition::Ir(ir) => {
217            let value = eval_ir(ir, interp, used)?;
218            value.as_bool().with_span(ir)?
219        }
220        ir::IrCondition::Let(ir_let) => {
221            let value = eval_ir(&ir_let.ir, interp, used)?;
222            ir_let.pat.matches(interp, value, ir)?
223        }
224    };
225
226    Ok(Value::from(value))
227}
228
229fn eval_ir_decl(
230    ir: &ir::IrDecl,
231    interp: &mut ir::Interpreter<'_, '_>,
232    used: Used,
233) -> Result<Value, EvalOutcome> {
234    interp.budget.take(ir)?;
235    let value = eval_ir(&ir.value, interp, used)?;
236    interp.scopes.decl(ir.name, value).with_span(ir)?;
237    Ok(Value::unit())
238}
239
240fn eval_ir_loop(
241    ir: &ir::IrLoop,
242    interp: &mut ir::Interpreter<'_, '_>,
243    used: Used,
244) -> Result<Value, EvalOutcome> {
245    let span = ir.span();
246    interp.budget.take(span)?;
247
248    let guard = interp.scopes.push()?;
249
250    let value = loop {
251        if let Some(condition) = &ir.condition {
252            interp.scopes.clear_current().with_span(condition)?;
253
254            let value = eval_ir_condition(condition, interp, used)?;
255
256            if !value.as_bool().with_span(condition)? {
257                break None;
258            }
259        }
260
261        match eval_ir_scope(&ir.body, interp, used) {
262            Ok(..) => (),
263            Err(outcome) => match outcome {
264                EvalOutcome::Break(span, label, expr) => {
265                    if label.as_deref() == ir.label.as_deref() {
266                        break expr;
267                    } else {
268                        return Err(EvalOutcome::Break(span, label, expr));
269                    }
270                }
271                outcome => return Err(outcome),
272            },
273        };
274    };
275
276    interp.scopes.pop(guard).with_span(ir)?;
277
278    if let Some(value) = value {
279        if ir.condition.is_some() {
280            return Err(EvalOutcome::from(compile::Error::msg(
281                span,
282                "break with value is not supported for unconditional loops",
283            )));
284        }
285
286        Ok(value)
287    } else {
288        Ok(Value::unit())
289    }
290}
291
292fn eval_ir_object(
293    ir: &ir::IrObject,
294    interp: &mut ir::Interpreter<'_, '_>,
295    used: Used,
296) -> Result<Value, EvalOutcome> {
297    let mut object = Object::with_capacity(ir.assignments.len())?;
298
299    for (key, value) in ir.assignments.iter() {
300        let key = key.as_ref().try_to_owned()?;
301        object.insert(key, eval_ir(value, interp, used)?)?;
302    }
303
304    Ok(Value::try_from(object).with_span(ir)?)
305}
306
307fn eval_ir_scope(
308    ir: &ir::IrScope,
309    interp: &mut ir::Interpreter<'_, '_>,
310    used: Used,
311) -> Result<Value, EvalOutcome> {
312    interp.budget.take(ir)?;
313    let guard = interp.scopes.push()?;
314
315    for ir in &ir.instructions {
316        let _ = eval_ir(ir, interp, used)?;
317    }
318
319    let value = if let Some(last) = &ir.last {
320        eval_ir(last, interp, used)?
321    } else {
322        Value::unit()
323    };
324
325    interp.scopes.pop(guard).with_span(ir)?;
326    Ok(value)
327}
328
329fn eval_ir_set(
330    ir: &ir::IrSet,
331    interp: &mut ir::Interpreter<'_, '_>,
332    used: Used,
333) -> Result<Value, EvalOutcome> {
334    interp.budget.take(ir)?;
335    let value = eval_ir(&ir.value, interp, used)?;
336    interp.scopes.set_target(&ir.target, value)?;
337    Ok(Value::unit())
338}
339
340fn eval_ir_template(
341    ir: &ir::IrTemplate,
342    interp: &mut ir::Interpreter<'_, '_>,
343    used: Used,
344) -> Result<Value, EvalOutcome> {
345    interp.budget.take(ir)?;
346
347    let mut buf = String::new();
348
349    for component in &ir.components {
350        match component {
351            ir::IrTemplateComponent::String(string) => {
352                buf.try_push_str(string)?;
353            }
354            ir::IrTemplateComponent::Ir(ir) => {
355                let const_value = eval_ir(ir, interp, used)?;
356
357                match const_value.as_ref() {
358                    Repr::Inline(Inline::Signed(integer)) => {
359                        write!(buf, "{integer}")?;
360                    }
361                    Repr::Inline(Inline::Float(float)) => {
362                        let mut buffer = ryu::Buffer::new();
363                        buf.try_push_str(buffer.format(*float))?;
364                    }
365                    Repr::Inline(Inline::Bool(b)) => {
366                        write!(buf, "{b}")?;
367                    }
368                    Repr::Any(value) if value.type_hash() == String::HASH => {
369                        let s = value.borrow_ref::<String>().with_span(ir)?;
370                        buf.try_push_str(&s)?;
371                    }
372                    _ => {
373                        return Err(EvalOutcome::not_const(ir));
374                    }
375                }
376            }
377        }
378    }
379
380    Ok(Value::try_from(buf).with_span(ir)?)
381}
382
383fn eval_ir_tuple(
384    ir: &ir::Tuple,
385    interp: &mut ir::Interpreter<'_, '_>,
386    used: Used,
387) -> Result<Value, EvalOutcome> {
388    let mut items = Vec::try_with_capacity(ir.items.len())?;
389
390    for item in ir.items.iter() {
391        items.try_push(eval_ir(item, interp, used)?)?;
392    }
393
394    let tuple = OwnedTuple::try_from(items).with_span(ir)?;
395    Ok(Value::try_from(tuple).with_span(ir)?)
396}
397
398fn eval_ir_vec(
399    ir: &ir::IrVec,
400    interp: &mut ir::Interpreter<'_, '_>,
401    used: Used,
402) -> Result<Value, EvalOutcome> {
403    let mut vec = Vec::try_with_capacity(ir.items.len())?;
404
405    for item in ir.items.iter() {
406        vec.try_push(eval_ir(item, interp, used)?)?;
407    }
408
409    let vec = crate::runtime::Vec::from(vec);
410    Ok(Value::try_from(vec).with_span(ir)?)
411}
412
413/// IrEval the interior expression.
414pub(crate) fn eval_ir(
415    ir: &ir::Ir,
416    interp: &mut ir::Interpreter<'_, '_>,
417    used: Used,
418) -> Result<Value, EvalOutcome> {
419    interp.budget.take(ir)?;
420
421    match &ir.kind {
422        ir::IrKind::Scope(ir) => eval_ir_scope(ir, interp, used),
423        ir::IrKind::Binary(ir) => eval_ir_binary(ir, interp, used),
424        ir::IrKind::Decl(ir) => eval_ir_decl(ir, interp, used),
425        ir::IrKind::Set(ir) => eval_ir_set(ir, interp, used),
426        ir::IrKind::Assign(ir) => eval_ir_assign(ir, interp, used),
427        ir::IrKind::Template(ir) => eval_ir_template(ir, interp, used),
428        ir::IrKind::Name(name) => Ok(interp.resolve_var(ir, name, used)?),
429        ir::IrKind::Target(target) => Ok(interp.scopes.get_target(target)?),
430        ir::IrKind::Value(value) => Ok(value.try_clone()?),
431        ir::IrKind::Branches(ir) => eval_ir_branches(ir, interp, used),
432        ir::IrKind::Loop(ir) => eval_ir_loop(ir, interp, used),
433        ir::IrKind::Break(ir) => Err(ir.as_outcome(interp, used)),
434        ir::IrKind::Vec(ir) => eval_ir_vec(ir, interp, used),
435        ir::IrKind::Tuple(ir) => eval_ir_tuple(ir, interp, used),
436        ir::IrKind::Object(ir) => eval_ir_object(ir, interp, used),
437        ir::IrKind::Call(ir) => eval_ir_call(ir, interp, used),
438    }
439}
rune/compile/ir/eval.rs

rune/compile/ir/
eval.rs
