Parse module params in import

crates/compiler/parse/src/ast.rs

@@ -246,6 +246,7 @@ impl<'a> Module<'a> {
                     name,
                 },
             },
+            params: None,
             alias: None,
             exposed: new_exposed,
         })
@@ -784,43 +785,6 @@ pub enum ValueDef<'a> {
 }
 
 impl<'a> ValueDef<'a> {
-    pub fn expr(&self) -> Option<&'a Expr<'a>> {
-        match self {
-            ValueDef::Body(_, body) => Some(&body.value),
-
-            ValueDef::AnnotatedBody {
-                ann_pattern: _,
-                ann_type: _,
-                comment: _,
-                body_pattern: _,
-                body_expr,
-            } => Some(&body_expr.value),
-
-            ValueDef::Dbg {
-                condition,
-                preceding_comment: _,
-            }
-            | ValueDef::Expect {
-                condition,
-                preceding_comment: _,
-            }
-            | ValueDef::ExpectFx {
-                condition,
-                preceding_comment: _,
-            } => Some(&condition.value),
-
-            ValueDef::Annotation(_, _)
-            | ValueDef::ModuleImport(ModuleImport {
-                before_name: _,
-                name: _,
-                alias: _,
-                exposed: _,
-            })
-            | ValueDef::IngestedFileImport(_) => None,
-            ValueDef::Stmt(loc_expr) => Some(&loc_expr.value),
-        }
-    }
-
     pub fn replace_expr(&mut self, new_expr: &'a Loc<Expr<'a>>) {
         match self {
             ValueDef::Body(_, expr) => *expr = new_expr,
@@ -1019,8 +983,47 @@ impl<'a, 'b> Iterator for RecursiveValueDefIter<'a, 'b> {
                     let def = &self.current.value_defs[def_index.index()];
                     let region = &self.current.regions[self.index];
 
-                    if let Some(expr) = def.expr() {
-                        self.push_pending_from_expr(expr);
+                    match def {
+                        ValueDef::Body(_, body) => self.push_pending_from_expr(&body.value),
+
+                        ValueDef::AnnotatedBody {
+                            ann_pattern: _,
+                            ann_type: _,
+                            comment: _,
+                            body_pattern: _,
+                            body_expr,
+                        } => self.push_pending_from_expr(&body_expr.value),
+
+                        ValueDef::Dbg {
+                            condition,
+                            preceding_comment: _,
+                        }
+                        | ValueDef::Expect {
+                            condition,
+                            preceding_comment: _,
+                        }
+                        | ValueDef::ExpectFx {
+                            condition,
+                            preceding_comment: _,
+                        } => self.push_pending_from_expr(&condition.value),
+
+                        ValueDef::ModuleImport(ModuleImport {
+                            before_name: _,
+                            name: _,
+                            alias: _,
+                            exposed: _,
+                            params,
+                        }) => {
+                            if let Some(ModuleImportParams { before: _, params }) = params {
+                                for loc_assigned_field in params.items {
+                                    if let Some(expr) = loc_assigned_field.value.value() {
+                                        self.push_pending_from_expr(&expr.value);
+                                    }
+                                }
+                            }
+                        }
+                        ValueDef::Stmt(loc_expr) => self.push_pending_from_expr(&loc_expr.value),
+                        ValueDef::Annotation(_, _) | ValueDef::IngestedFileImport(_) => {}
                     }
 
                     self.index += 1;
@@ -1046,6 +1049,7 @@ impl<'a, 'b> Iterator for RecursiveValueDefIter<'a, 'b> {
 pub struct ModuleImport<'a> {
     pub before_name: &'a [CommentOrNewline<'a>],
     pub name: Loc<ImportedModuleName<'a>>,
+    pub params: Option<ModuleImportParams<'a>>,
     pub alias: Option<header::KeywordItem<'a, ImportAsKeyword, Loc<ImportAlias<'a>>>>,
     pub exposed: Option<
         header::KeywordItem<
@@ -1056,6 +1060,12 @@ pub struct ModuleImport<'a> {
     >,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct ModuleImportParams<'a> {
+    pub before: &'a [CommentOrNewline<'a>],
+    pub params: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct IngestedFileImport<'a> {
     pub before_path: &'a [CommentOrNewline<'a>],
@@ -1537,6 +1547,20 @@ pub enum AssignedField<'a, Val> {
     Malformed(&'a str),
 }
 
+impl<'a, Val> AssignedField<'a, Val> {
+    pub fn value(&self) -> Option<&Loc<Val>> {
+        let mut current = self;
+
+        loop {
+            match current {
+                Self::RequiredValue(_, _, val) | Self::OptionalValue(_, _, val) => break Some(val),
+                Self::LabelOnly(_) | Self::Malformed(_) => break None,
+                Self::SpaceBefore(next, _) | Self::SpaceAfter(next, _) => current = *next,
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum RecordBuilderField<'a> {
     // A field with a value, e.g. `{ name: "blah" }`
@@ -2635,9 +2659,10 @@ impl<'a> Malformed for ValueDef<'a> {
             ValueDef::ModuleImport(ModuleImport {
                 before_name: _,
                 name: _,
+                params,
                 alias: _,
                 exposed: _,
-            }) => false,
+            }) => params.is_malformed(),
             ValueDef::IngestedFileImport(IngestedFileImport {
                 before_path: _,
                 path,
@@ -2649,6 +2674,14 @@ impl<'a> Malformed for ValueDef<'a> {
     }
 }
 
+impl<'a> Malformed for ModuleImportParams<'a> {
+    fn is_malformed(&self) -> bool {
+        let Self { before: _, params } = self;
+
+        params.is_malformed()
+    }
+}
+
 impl<'a> Malformed for TypeAnnotation<'a> {
     fn is_malformed(&self) -> bool {
         match self {

crates/compiler/parse/src/expr.rs

@@ -1,8 +1,9 @@
 use crate::ast::{
     is_expr_suffixed, AssignedField, Collection, CommentOrNewline, Defs, Expr, ExtractSpaces,
     Implements, ImplementsAbilities, ImportAlias, ImportAsKeyword, ImportExposingKeyword,
-    ImportedModuleName, IngestedFileAnnotation, IngestedFileImport, ModuleImport, Pattern,
-    RecordBuilderField, Spaceable, Spaced, Spaces, TypeAnnotation, TypeDef, TypeHeader, ValueDef,
+    ImportedModuleName, IngestedFileAnnotation, IngestedFileImport, ModuleImport,
+    ModuleImportParams, Pattern, RecordBuilderField, Spaceable, Spaced, Spaces, TypeAnnotation,
+    TypeDef, TypeHeader, ValueDef,
 };
 use crate::blankspace::{
     space0_after_e, space0_around_e_no_after_indent_check, space0_around_ee, space0_before_e,
@@ -15,8 +16,8 @@ use crate::module::module_name_help;
 use crate::parser::{
     self, backtrackable, byte, byte_indent, increment_min_indent, line_min_indent, optional,
     reset_min_indent, sep_by1, sep_by1_e, set_min_indent, specialize_err, specialize_err_ref, then,
-    two_bytes, EClosure, EExpect, EExpr, EIf, EImport, EInParens, EList, ENumber, EPattern,
-    ERecord, EString, EType, EWhen, Either, ParseResult, Parser,
+    two_bytes, EClosure, EExpect, EExpr, EIf, EImport, EImportParams, EInParens, EList, ENumber,
+    EPattern, ERecord, EString, EType, EWhen, Either, ParseResult, Parser,
 };
 use crate::pattern::{closure_param, loc_implements_parser};
 use crate::state::State;
@@ -993,6 +994,7 @@ fn import_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> {
         record!(ModuleImport {
             before_name: space0_e(EImport::IndentStart),
             name: loc!(imported_module_name()),
+            params: optional(specialize_err(EImport::Params, import_params())),
             alias: optional(import_as()),
             exposed: optional(import_exposing())
         }),
@@ -1000,6 +1002,37 @@ fn import_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>> {
     )
 }
 
+fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<'a>> {
+    then(
+        and!(
+            backtrackable(space0_e(EImportParams::Indent)),
+            specialize_err(EImportParams::Record, record_help())
+        ),
+        |arena, state, _, (before, record): (_, RecordHelp<'a>)| {
+            if let Some(update) = record.update {
+                return Err((
+                    MadeProgress,
+                    EImportParams::RecordUpdateFound(update.region),
+                ));
+            }
+
+            let params = record.fields.map_items_result(arena, |loc_field| {
+                match loc_field.value.to_assigned_field(arena) {
+                    Ok(field) => Ok(loc_field.map(|_| field)),
+                    Err(FoundApplyValue) => Err((
+                        MadeProgress,
+                        EImportParams::RecordApplyFound(loc_field.region),
+                    )),
+                }
+            })?;
+
+            let import_params = ModuleImportParams { before, params };
+
+            Ok((MadeProgress, import_params, state))
+        },
+    )
+}
+
 #[inline(always)]
 fn imported_module_name<'a>() -> impl Parser<'a, ImportedModuleName<'a>, EImport<'a>> {
     record!(ImportedModuleName {

crates/compiler/parse/src/parser.rs

@@ -90,6 +90,7 @@ impl_space_problem! {
     EImport<'a>,
     EParams<'a>,
     EImports,
+    EImportParams<'a>,
     EInParens<'a>,
     EClosure<'a>,
     EList<'a>,
@@ -541,6 +542,7 @@ pub enum EImport<'a> {
     PackageShorthand(Position),
     PackageShorthandDot(Position),
     ModuleName(Position),
+    Params(EImportParams<'a>, Position),
     IndentAs(Position),
     As(Position),
     IndentAlias(Position),
@@ -563,6 +565,15 @@ pub enum EImport<'a> {
     EndNewline(Position),
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EImportParams<'a> {
+    Indent(Position),
+    Record(ERecord<'a>, Position),
+    RecordUpdateFound(Region),
+    RecordApplyFound(Region),
+    Space(BadInputError, Position),
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EPattern<'a> {
     Record(PRecord<'a>, Position),