Lower params when calling imported functions

crates/compiler/lower_params/src/lib.rs

@@ -0,0 +1,106 @@
+use roc_can::{
+    expr::{
+        AnnotatedMark, ClosureData,
+        DeclarationTag::*,
+        Declarations,
+        Expr::{self, *},
+    },
+    pattern::Pattern,
+};
+use roc_region::all::Loc;
+use roc_types::subs::{VarStore, Variable};
+use roc_types::types::Type;
+
+struct LowerParams {
+    home_params: Option<HomeParams>,
+}
+
+type HomeParams = (Variable, AnnotatedMark, Loc<Pattern>);
+
+pub fn lower(home_params: Option<HomeParams>, decls: &mut Declarations, var_store: &mut VarStore) {
+    let env = LowerParams { home_params };
+
+    let mut index = 0;
+
+    while index < decls.len() {
+        let tag = decls.declarations[index];
+
+        match tag {
+            Value => {
+                // todo: thunk in module with params
+                env.lower_expr(&mut decls.expressions[index].value)
+            }
+            Function(fn_def_index) => {
+                if let Some((_, mark, pattern)) = env.home_params.clone() {
+                    let var = var_store.fresh();
+
+                    decls.function_bodies[fn_def_index.index()]
+                        .value
+                        .arguments
+                        .push((var, mark, pattern));
+
+                    if let Some(ann) = &mut decls.annotations[index] {
+                        if let Type::Function(args, _, _) = &mut ann.signature {
+                            args.push(Type::Variable(var))
+                        }
+                    }
+                }
+
+                env.lower_expr(&mut decls.expressions[index].value)
+            }
+
+            Recursive(_) => { /* todo */ }
+            MutualRecursion { length, .. } => {
+                /* todo */
+                index += length as usize;
+            }
+            TailRecursive(_) => { /* todo */ }
+            Destructure(_) => { /* todo */ }
+            Expectation => { /* todo */ }
+            ExpectationFx => { /* todo */ }
+        }
+
+        index += 1;
+    }
+}
+
+impl LowerParams {
+    fn lower_expr(&self, expr: &mut Expr) {
+        match expr {
+            Call(fun, args, _called_via) => {
+                for arg in args.iter_mut() {
+                    // todo: params var in arg
+                    self.lower_expr(&mut arg.1.value);
+                }
+
+                match fun.1.value {
+                    ParamsVar {
+                        symbol,
+                        var,
+                        params_var,
+                        params_symbol,
+                    } => {
+                        args.push((params_var, Loc::at_zero(Var(params_symbol, params_var))));
+                        fun.1.value = Var(symbol, var);
+                    }
+                    _ => self.lower_expr(&mut fun.1.value),
+                }
+            }
+            Closure(ClosureData {
+                function_type: _,
+                closure_type: _,
+                return_type: _,
+                name: _,
+                captured_symbols: _,
+                recursive: _,
+                arguments: _,
+                loc_body,
+            }) => {
+                // todo: capture params?
+
+                self.lower_expr(&mut loc_body.value);
+            }
+            _ => { /* todo */ }
+        }
+    }
+}