Refactor: Move inlining logic to Inliner struct

Introduces the `Inliner` struct to encapsulate logic related to value
and function inlining. This improves code organization and readability
within the optimizer engine.

Key changes include:
- Moving `is_inlinable_value` to the `Inliner` struct.
- Extracting beta-reduction preparation logic into
  `Inliner::prepare_beta_reduction`.
- Moving parameter slot collection to
  `Inliner::collect_parameter_slots`.
- Introducing `flatten_tuple` to a new `utils` module, used by both
  `Folder` and `Inliner`.

src/ast/compiler/optimizer/inliner.rs

@@ -0,0 +1,207 @@
+use crate::ast::compiler::bound_nodes::{Address, AnalyzedNode, BoundKind, GlobalIdx, LocalSlot};
+use crate::ast::types::{Purity, Value};
+use crate::ast::vm::Closure;
+use std::cell::RefCell;
+use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
+
+use super::substitution_map::{SubstitutionMap, UsageInfo};
+use super::utils::flatten_tuple;
+
+pub struct Inliner<'a> {
+    pub globals: &'a Option<Rc<RefCell<Vec<Value>>>>,
+    pub global_purity: &'a Option<Rc<RefCell<HashMap<GlobalIdx, Purity>>>>,
+}
+
+impl<'a> Inliner<'a> {
+    pub fn new(
+        globals: &'a Option<Rc<RefCell<Vec<Value>>>>,
+        global_purity: &'a Option<Rc<RefCell<HashMap<GlobalIdx, Purity>>>>,
+    ) -> Self {
+        Self {
+            globals,
+            global_purity,
+        }
+    }
+
+    pub fn is_inlinable_value(&self, val: &Value, addr: Address) -> bool {
+        let type_ok = match val {
+            Value::Int(_)
+            | Value::Float(_)
+            | Value::Bool(_)
+            | Value::Text(_)
+            | Value::Keyword(_)
+            | Value::DateTime(_) => true,
+            Value::Object(obj) => {
+                if let Some(closure) = obj.as_any().downcast_ref::<Closure>() {
+                    closure.upvalues.is_empty() && !closure.function_node.ty.is_recursive
+                } else {
+                    false
+                }
+            }
+            _ => false,
+        };
+
+        if !type_ok {
+            return false;
+        }
+
+        if let Address::Global(idx) = addr {
+            if let Some(purity_rc) = &self.global_purity {
+                let purity = purity_rc
+                    .borrow()
+                    .get(&idx)
+                    .cloned()
+                    .unwrap_or(Purity::Impure);
+                return purity >= Purity::Pure;
+            }
+            return false;
+        }
+
+        true
+    }
+
+    pub fn prepare_beta_reduction(
+        &self,
+        params: &AnalyzedNode,
+        args: &AnalyzedNode,
+        body: &AnalyzedNode,
+        sub: &mut SubstitutionMap,
+    ) -> Option<()> {
+        let mut body_usage = UsageInfo::default();
+        body_usage.collect(body);
+
+        let mut arg_vals = Vec::new();
+        flatten_tuple(args.clone(), &mut arg_vals);
+
+        let mut slot_index = 0;
+        self.map_params_to_args(params, &arg_vals, &mut slot_index, sub, &body_usage);
+
+        if slot_index != arg_vals.len() {
+            return None;
+        }
+
+        let mut param_slots = HashSet::new();
+        self.collect_parameter_slots_set(params, &mut param_slots);
+
+        for slot in param_slots {
+            let addr = Address::Local(slot);
+            if (body_usage.is_used(&addr) || body_usage.is_assigned(&addr))
+                && sub.get_value(&addr).is_none()
+                && !sub.ast_substitutions.contains_key(&addr)
+            {
+                return None;
+            }
+        }
+
+        if sub.values.is_empty() && sub.ast_substitutions.is_empty() && !arg_vals.is_empty() {
+            return None;
+        }
+
+        Some(())
+    }
+
+    pub fn map_params_to_args(
+        &self,
+        pattern: &AnalyzedNode,
+        args: &[AnalyzedNode],
+        offset: &mut usize,
+        sub: &mut SubstitutionMap,
+        body_usage: &UsageInfo,
+    ) {
+        match &pattern.kind {
+            BoundKind::Define { addr, .. } => {
+                if let Some(arg) = args.get(*offset)
+                    && !body_usage.is_assigned(addr)
+                {
+                    if let BoundKind::Constant(val) = &arg.kind {
+                        sub.add_value(*addr, val.clone());
+                    } else if let BoundKind::Lambda { upvalues, .. } = &arg.kind
+                        && upvalues.is_empty()
+                    {
+                        sub.add_ast_substitution(*addr, arg.clone());
+                    } else if let BoundKind::Get {
+                        addr: Address::Global(_),
+                        ..
+                    } = &arg.kind
+                    {
+                        sub.add_ast_substitution(*addr, arg.clone());
+                    }
+                }
+
+                if let Address::Local(slot) = addr {
+                    sub.slot_mapping.insert(*slot, *slot);
+                    sub.next_slot = sub.next_slot.max(slot.0 + 1);
+                }
+                *offset += 1;
+            }
+            BoundKind::Tuple { elements } => {
+                if let Some(arg) = args.get(*offset) {
+                    let mut sub_args = Vec::new();
+                    let is_compound = match &arg.kind {
+                        BoundKind::Tuple { .. } | BoundKind::Record { .. } => {
+                            flatten_tuple(arg.clone(), &mut sub_args);
+                            true
+                        }
+                        _ => false,
+                    };
+
+                    if is_compound {
+                        let mut sub_offset = 0;
+                        for el in elements {
+                            self.map_params_to_args(
+                                el,
+                                &sub_args,
+                                &mut sub_offset,
+                                sub,
+                                body_usage,
+                            );
+                        }
+                        *offset += 1;
+                        return;
+                    }
+                }
+
+                for el in elements {
+                    self.map_params_to_args(el, args, offset, sub, body_usage);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    pub fn collect_parameter_slots_set(&self, node: &AnalyzedNode, slots: &mut HashSet<LocalSlot>) {
+        match &node.kind {
+            BoundKind::Define {
+                addr: Address::Local(slot),
+                ..
+            } => {
+                slots.insert(*slot);
+            }
+            BoundKind::Tuple { elements } => {
+                for el in elements {
+                    self.collect_parameter_slots_set(el, slots);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    pub fn collect_parameter_slots(&self, node: &AnalyzedNode, sub: &mut SubstitutionMap) {
+        match &node.kind {
+            BoundKind::Define {
+                addr: Address::Local(slot),
+                ..
+            } => {
+                sub.slot_mapping.insert(*slot, *slot);
+                sub.next_slot = sub.next_slot.max(slot.0 + 1);
+            }
+            BoundKind::Tuple { elements } => {
+                for el in elements {
+                    self.collect_parameter_slots(el, sub);
+                }
+            }
+            _ => {}
+        }
+    }
+}