loft 0.0.1-alpha.22

Rusty embedded scripting 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
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use super::*;

use crate::runtime::value::{Value, ValueEnum, ValueType};
use std::collections::{HashMap, HashSet};
use std::{cell::RefCell, rc::Rc};

impl Environment {
    /// Recursively converts a value and its inner fields to mutable.
    /// Uses cycle detection to avoid processing self-referential values.
    pub fn make_deeply_mutable(&self, value: Value) -> Value {
        let mut visited: HashSet<*const RefCell<ValueEnum>> = HashSet::new();
        self.make_deeply_mutable_internal(value, &mut visited)
    }

    /// Recursively converts a value and its inner fields to immutable.
    /// Uses cycle detection to avoid processing self-referential values.
    pub fn make_deeply_immutable(&self, value: Value) -> Value {
        let mut visited: HashSet<*const RefCell<ValueEnum>> = HashSet::new();
        self.make_deeply_immutable_internal(value, &mut visited)
    }

    /// Internal helper that performs recursion with cycle detection.
    fn make_deeply_mutable_internal(&self, value: Value, visited: &mut HashSet<*const RefCell<ValueEnum>>) -> Value {
        let ptr = Rc::as_ptr(&value);

        if visited.contains(&ptr) {
            return value;
        }

        visited.insert(ptr);

        let new_inner = {
            let borrowed = value.borrow();
            match borrowed.inner() {
                ValueType::Struct { name, fields } => {
                    let mut mutable_fields = HashMap::new();
                    for (field_name, field_value) in fields {
                        let mutable_value = self.make_deeply_mutable_internal(field_value.clone(), visited);
                        mutable_fields.insert(field_name.clone(), mutable_value);
                    }

                    ValueType::Struct {
                        name: name.clone(),
                        fields: mutable_fields,
                    }
                }

                ValueType::Reference {
                    source_name,
                    source_scope,
                    original_ptr,
                    _undropped,
                } => ValueType::Reference {
                    source_name: source_name.clone(),
                    source_scope,
                    original_ptr,
                    _undropped: _undropped.clone(),
                },

                other => other.clone(),
            }
        };

        {
            let mut borrowed = value.borrow_mut();
            *borrowed = ValueEnum::Mutable(new_inner);
        }

        visited.remove(&ptr);
        return value;
    }

    fn make_deeply_immutable_internal(&self, value: Value, visited: &mut HashSet<*const RefCell<ValueEnum>>) -> Value {
        let ptr = Rc::as_ptr(&value);

        if visited.contains(&ptr) {
            return value;
        }

        visited.insert(ptr);

        let new_inner = {
            let borrowed = value.borrow();
            match borrowed.inner() {
                ValueType::Struct { name, fields } => {
                    let mut immutable_fields = HashMap::new();
                    for (field_name, field_value) in fields {
                        let immutable_value = self.make_deeply_immutable_internal(field_value.clone(), visited);
                        immutable_fields.insert(field_name.clone(), immutable_value);
                    }

                    ValueType::Struct {
                        name: name.clone(),
                        fields: immutable_fields,
                    }
                }

                ValueType::Reference {
                    source_name,
                    source_scope,
                    original_ptr,
                    _undropped,
                } => ValueType::Reference {
                    source_name: source_name.clone(),
                    source_scope,
                    original_ptr,
                    _undropped: _undropped.clone(),
                },

                other => other.clone(),
            }
        };

        {
            let mut borrowed = value.borrow_mut();
            *borrowed = ValueEnum::Immutable(new_inner);
        }

        visited.remove(&ptr);
        return value;
    }
}