use super::{Expression, Name};
use std::collections::HashMap;

impl Expression {
    /// Replace all references in the given map to their alternative expression values
    pub fn replace_references(&mut self, map: &mut HashMap<Name, Expression>) {
        match self {
            Expression::Value(_, _) => {}
            Expression::Constructor(_, _, items) => {
                for (_, item) in items.iter_mut() {
                    item.replace_references(map);
                }
            }
            Expression::Reference(name) => match map.get(name) {
                None => {}
                Some(x) => *self = x.clone(),
            },
            Expression::FieldRef(_, subexp, _) => {
                subexp.replace_references(map);
            }
            Expression::Cast(_, _, subexp) => {
                subexp.replace_references(map);
            }
            Expression::Primitive(_, _) => {}
            Expression::Call(_, fun, args) => {
                fun.replace_references(map);
                for arg in args.iter_mut() {
                    arg.replace_references(map);
                }
            }
            Expression::Block(_, exprs) => {
                for expr in exprs.iter_mut() {
                    expr.replace_references(map);
                }
            }
            Expression::Binding(_, n, expr) => {
                expr.replace_references(map);
                map.remove(n);
            }
            Expression::Function(_, mname, args, _, body) => {
                if let Some(name) = mname {
                    map.remove(name);
                }
                for (arg_name, _) in args.iter() {
                    map.remove(arg_name);
                }
                body.replace_references(map);
            }
        }
    }
}