Merge branch 'main' into inline-imports

crates/compiler/parse/src/blankspace.rs

@@ -197,17 +197,12 @@ where
     )
 }
 
-pub fn check_indent<'a, E>(
-    indent_problem: fn(Position) -> E,
-    inside_suffixed_statement: bool,
-) -> impl Parser<'a, (), E>
+pub fn check_indent<'a, E>(indent_problem: fn(Position) -> E) -> impl Parser<'a, (), E>
 where
     E: 'a,
 {
-    let extra_spaces = if inside_suffixed_statement { 1 } else { 0 };
-
     move |_, state: State<'a>, min_indent: u32| {
-        if state.column() >= (min_indent + extra_spaces) {
+        if state.column() >= min_indent {
             Ok((NoProgress, (), state))
         } else {
             Err((NoProgress, indent_problem(state.pos())))

crates/compiler/parse/src/expr.rs

@@ -1772,11 +1772,13 @@ fn finish_parsing_ability_def_help<'a>(
     Ok((MadeProgress, (type_def, def_region), state))
 }
 
+#[allow(clippy::too_many_arguments)]
 fn parse_expr_operator<'a>(
     min_indent: u32,
     options: ExprParseOptions,
     mut expr_state: ExprState<'a>,
     loc_op: Loc<BinOp>,
+    line_indent: u32,
     arena: &'a Bump,
     state: State<'a>,
     initial_state: State<'a>,
@@ -1821,7 +1823,8 @@ fn parse_expr_operator<'a>(
         }
         BinOp::Assignment => {
             let expr_region = expr_state.expr.region;
-            let indented_more = min_indent + 1;
+
+            let indented_more = line_indent + 1;
 
             let call = expr_state
                 .validate_assignment_or_backpassing(arena, loc_op, EExpr::ElmStyleFunction)
@@ -2028,12 +2031,18 @@ fn parse_expr_end<'a>(
     state: State<'a>,
     initial_state: State<'a>,
 ) -> ParseResult<'a, Expr<'a>, EExpr<'a>> {
+    let inner_min_indent = if options.suffixed_found {
+        min_indent + 1
+    } else {
+        min_indent
+    };
+
     let parser = skip_first!(
-        crate::blankspace::check_indent(EExpr::IndentEnd, options.suffixed_found),
+        crate::blankspace::check_indent(EExpr::IndentEnd),
         loc_term_or_underscore(options)
     );
 
-    match parser.parse(arena, state.clone(), min_indent) {
+    match parser.parse(arena, state.clone(), inner_min_indent) {
         Err((MadeProgress, f)) => Err((MadeProgress, f)),
         Ok((
             _,
@@ -2135,6 +2144,7 @@ fn parse_expr_end<'a>(
         Err((NoProgress, _)) => {
             let before_op = state.clone();
             // try an operator
+            let line_indent = state.line_indent();
             match loc!(operator()).parse(arena, state.clone(), min_indent) {
                 Err((MadeProgress, f)) => Err((MadeProgress, f)),
                 Ok((_, loc_op, state)) => {
@@ -2145,6 +2155,7 @@ fn parse_expr_end<'a>(
                         options,
                         expr_state,
                         loc_op,
+                        line_indent,
                         arena,
                         state,
                         initial_state,

crates/compiler/parse/src/pattern.rs

@@ -46,7 +46,7 @@ pub fn closure_param<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {
 
 pub fn loc_pattern_help<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {
     move |arena, state: State<'a>, min_indent| {
-        let (_, pattern, state) = loc_pattern_help_help().parse(arena, state, min_indent)?;
+        let (_, pattern, state) = loc_pattern_help_help(true).parse(arena, state, min_indent)?;
 
         let pattern_state = state.clone();
 
@@ -82,11 +82,13 @@ pub fn loc_pattern_help<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>>
     }
 }
 
-fn loc_pattern_help_help<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {
+fn loc_pattern_help_help<'a>(
+    can_have_arguments: bool,
+) -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {
     one_of!(
         specialize_err(EPattern::PInParens, loc_pattern_in_parens_help()),
         loc!(underscore_pattern_help()),
-        loc_ident_pattern_help(true),
+        loc_ident_pattern_help(can_have_arguments),
         loc!(specialize_err(
             EPattern::Record,
             crate::pattern::record_pattern_help()
@@ -143,7 +145,8 @@ fn loc_tag_pattern_arg<'a>(
             min_indent,
         )?;
 
-        let (_, loc_pat, state) = loc_parse_tag_pattern_arg().parse(arena, state, min_indent)?;
+        // Cannot have arguments here, pass `false` to make sure `Foo Bar 1` is parsed as `Foo (Bar) 1`, and not `Foo (Bar 1)`
+        let (_, loc_pat, state) = loc_pattern_help_help(false).parse(arena, state, min_indent)?;
 
         let Loc { region, value } = loc_pat;
 
@@ -194,21 +197,6 @@ pub fn loc_implements_parser<'a>() -> impl Parser<'a, Loc<Implements<'a>>, EPatt
     )
 }
 
-fn loc_parse_tag_pattern_arg<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {
-    one_of!(
-        specialize_err(EPattern::PInParens, loc_pattern_in_parens_help()),
-        loc!(underscore_pattern_help()),
-        // Make sure `Foo Bar 1` is parsed as `Foo (Bar) 1`, and not `Foo (Bar 1)`
-        loc_ident_pattern_help(false),
-        loc!(specialize_err(
-            EPattern::Record,
-            crate::pattern::record_pattern_help()
-        )),
-        loc!(string_like_pattern_help()),
-        loc!(number_pattern_help())
-    )
-}
-
 fn loc_pattern_in_parens_help<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, PInParens<'a>> {
     then(
         loc!(collection_trailing_sep_e!(