CHECKPOINT: Everything builds again.

src/syntax/replace_references.rs

@@ -0,0 +1,51 @@
+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);
+            }
+        }
+    }
+}