solilang 0.21.1

A statically-typed, class-based OOP language with pipeline operators
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

//! Array literal evaluation.

use std::cell::RefCell;
use std::rc::Rc;

use crate::ast::{Expr, ExprKind};
use crate::error::RuntimeError;
use crate::interpreter::executor::{Interpreter, RuntimeResult};
use crate::interpreter::value::Value;

impl Interpreter {
    /// Evaluate array literal expression: [elements]
    pub(crate) fn evaluate_array(&mut self, elements: &Vec<Expr>) -> RuntimeResult<Value> {
        let mut values = Vec::new();
        for elem in elements {
            match &elem.kind {
                ExprKind::Spread(inner) => {
                    // Evaluate the spread expression and extend with its elements
                    let spread_val = self.evaluate(inner)?;
                    match spread_val {
                        Value::Array(ref arr) => {
                            let arr = arr.borrow();
                            values.extend(arr.clone());
                        }
                        _ => {
                            return Err(RuntimeError::type_error(
                                "cannot spread non-array value",
                                elem.span,
                            ));
                        }
                    }
                }
                _ => {
                    values.push(self.evaluate(elem)?);
                }
            }
        }
        Ok(Value::Array(Rc::new(RefCell::new(values))))
    }
}