From dd0e28240a3f1681978f1be74599e258e16cef5a Mon Sep 17 00:00:00 2001
From: Agus Zubiaga <hi@aguz.me>
Date: Thu, 30 May 2024 20:11:51 -0300
Subject: [PATCH] Add module param identifiers to solve's scope

---
 crates/compiler/load/tests/helpers/mod.rs |  1 +
 crates/compiler/load_internal/src/file.rs |  2 ++
 crates/compiler/solve/src/module.rs       |  3 +++
 crates/compiler/solve/src/solve.rs        |  9 +++++--
 crates/compiler/solve/src/solve/scope.rs  | 32 ++++++++++++++++++++++-
 crates/compiler/test_derive/src/util.rs   |  1 +
 6 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/crates/compiler/load/tests/helpers/mod.rs b/crates/compiler/load/tests/helpers/mod.rs
index e8110e4d63..aa14df2326 100644
--- a/crates/compiler/load/tests/helpers/mod.rs
+++ b/crates/compiler/load/tests/helpers/mod.rs
@@ -51,6 +51,7 @@ pub fn infer_expr(
         exposed_by_module: &Default::default(),
         derived_module,
         function_kind: FunctionKind::LambdaSet,
+        params_pattern: None,
         #[cfg(debug_assertions)]
         checkmate: None,
     };
diff --git a/crates/compiler/load_internal/src/file.rs b/crates/compiler/load_internal/src/file.rs
index 700e9532ee..b8c80c3792 100644
--- a/crates/compiler/load_internal/src/file.rs
+++ b/crates/compiler/load_internal/src/file.rs
@@ -4613,6 +4613,7 @@ fn run_solve_solve(
         aliases,
         rigid_variables,
         abilities_store: pending_abilities,
+        params_pattern,
         ..
     } = module;
 
@@ -4660,6 +4661,7 @@ fn run_solve_solve(
             derived_module,
             #[cfg(debug_assertions)]
             checkmate,
+            params_pattern: params_pattern.map(|(_, _, pattern)| pattern.value),
         };
 
         let solve_output = roc_solve::module::run_solve(
diff --git a/crates/compiler/solve/src/module.rs b/crates/compiler/solve/src/module.rs
index 77b4bf2aa6..dea688c527 100644
--- a/crates/compiler/solve/src/module.rs
+++ b/crates/compiler/solve/src/module.rs
@@ -80,6 +80,9 @@ pub struct SolveConfig<'a> {
     #[cfg(debug_assertions)]
     /// The checkmate collector for this module.
     pub checkmate: Option<roc_checkmate::Collector>,
+
+    /// Module params pattern
+    pub params_pattern: Option<roc_can::pattern::Pattern>,
 }
 
 pub struct SolveOutput {
diff --git a/crates/compiler/solve/src/solve.rs b/crates/compiler/solve/src/solve.rs
index 95dafa4851..92525f7f61 100644
--- a/crates/compiler/solve/src/solve.rs
+++ b/crates/compiler/solve/src/solve.rs
@@ -129,15 +129,18 @@ fn run_help(
         exposed_by_module,
         derived_module,
         function_kind,
+        params_pattern,
         ..
     } = config;
 
     let mut pools = Pools::default();
 
+    // todo(agus): Do we need state here?
     let state = State {
-        scope: Scope::default(),
+        scope: Scope::new(None),
         mark: Mark::NONE.next(),
     };
+
     let rank = Rank::toplevel();
     let arena = Bump::new();
 
@@ -186,6 +189,7 @@ fn run_help(
         abilities_store,
         &mut obligation_cache,
         &mut awaiting_specializations,
+        params_pattern,
     );
 
     RunSolveOutput {
@@ -244,9 +248,10 @@ fn solve(
     abilities_store: &mut AbilitiesStore,
     obligation_cache: &mut ObligationCache,
     awaiting_specializations: &mut AwaitingSpecializations,
+    params_pattern: Option<roc_can::pattern::Pattern>,
 ) -> State {
     let initial = Work::Constraint {
-        scope: &Scope::default(),
+        scope: &Scope::new(params_pattern),
         rank,
         constraint,
     };
diff --git a/crates/compiler/solve/src/solve/scope.rs b/crates/compiler/solve/src/solve/scope.rs
index 5acd041c96..9214a9d6b2 100644
--- a/crates/compiler/solve/src/solve/scope.rs
+++ b/crates/compiler/solve/src/solve/scope.rs
@@ -2,13 +2,43 @@ use roc_module::symbol::Symbol;
 use roc_types::subs::Variable;
 
 /// The scope of the solver, as symbols are introduced.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct Scope {
     symbols: Vec<Symbol>,
     variables: Vec<Variable>,
 }
 
 impl Scope {
+    pub fn new(params_pattern: Option<roc_can::pattern::Pattern>) -> Self {
+        match params_pattern {
+            Some(params_pattern) => match params_pattern {
+                roc_can::pattern::Pattern::RecordDestructure {
+                    whole_var: _,
+                    ext_var: _,
+                    destructs,
+                } => {
+                    let mut symbols = Vec::with_capacity(destructs.len());
+                    let mut variables = Vec::with_capacity(destructs.len());
+
+                    for destruct in destructs {
+                        symbols.push(destruct.value.symbol);
+                        variables.push(destruct.value.var);
+                    }
+
+                    Self { symbols, variables }
+                }
+                _ => unreachable!(
+                    "other pattern types should have parsed: {:?}",
+                    params_pattern
+                ),
+            },
+            None => Self {
+                symbols: Vec::default(),
+                variables: Vec::default(),
+            },
+        }
+    }
+
     pub fn vars_by_symbol(&self) -> impl Iterator<Item = (Symbol, Variable)> + '_ {
         let it1 = self.symbols.iter().copied();
         let it2 = self.variables.iter().copied();
diff --git a/crates/compiler/test_derive/src/util.rs b/crates/compiler/test_derive/src/util.rs
index 0fbb02e9be..8c80045060 100644
--- a/crates/compiler/test_derive/src/util.rs
+++ b/crates/compiler/test_derive/src/util.rs
@@ -438,6 +438,7 @@ fn check_derived_typechecks_and_golden(
         pending_derives: Default::default(),
         exposed_by_module: &exposed_for_module.exposed_by_module,
         derived_module: Default::default(),
+        params_pattern: None,
 
         #[cfg(debug_assertions)]
         checkmate: None,