fixed formatting

Author: alex-snezhko

compiler/src/formatting/format.re

@@ -2974,9 +2974,53 @@ and print_expression_inner =
     | PExpCollectionConcat(concat_t, collections) =>
       let list_length = List.length(collections);
 
+      let flattened =
+        List.map(
+          ((t, e)) => {
+            let process_elem =
+              switch (concat_t) {
+              | PExpListConcat =>
+                let rec process_elem = list => {
+                  switch (list.Parsetree.pexp_desc) {
+                  | Parsetree.PExpConstruct(
+                      {txt: IdentName({txt: "[...]"})},
+                      PExpConstrTuple([expr, rest]),
+                    ) =>
+                    switch (rest.pexp_desc) {
+                    | Parsetree.PExpConstruct(
+                        {txt: IdentName({txt: "[]"})},
+                        PExpConstrTuple(_),
+                      ) =>
+                      // Non-spread element at end of list; do not recurse
+                      [(false, expr)]
+                    | _ => [(false, expr), ...process_elem(rest)]
+                    }
+                  | _ => [(true, list)]
+                  };
+                };
+                process_elem;
+              | PExpArrayConcat => (
+                  array => {
+                    switch (array.Parsetree.pexp_desc) {
+                    | Parsetree.PExpArray(elems) =>
+                      List.map(elem => (false, elem), elems)
+                    | _ => assert(false)
+                    };
+                  }
+                )
+              };
+            switch (t) {
+            | Parsetree.PExpSpreadExpr => [(true, e)]
+            | Parsetree.PExpNonSpreadExpr => process_elem(e)
+            };
+          },
+          collections,
+        )
+        |> List.flatten;
+
       let items =
         List.mapi(
-          (index, (t, e)) => {
+          (index, (is_spread, e)) => {
             // Do we have any comments on this line?
             // If so, we break the whole list
 
@@ -3005,24 +3049,12 @@ and print_expression_inner =
               };
 
             let expr =
-              switch (t) {
-              | Parsetree.PExpNonSpreadExpr =>
-                let e =
-                  switch (concat_t, e.pexp_desc) {
-                  | (
-                      PExpListConcat,
-                      Parsetree.PExpConstruct(
-                        {txt: IdentName({txt: "[...]"})},
-                        PExpConstrTuple([expr, _]),
-                      ),
-                    )
-                  | (PExpArrayConcat, Parsetree.PExpArray([expr])) => expr
-                  | _ =>
-                    failwith(
-                      "Impossible: formatter: non-spread concat item containing invalid data",
-                    )
-                  };
-
+              Doc.concat([
+                if (is_spread) {
+                  Doc.text("...");
+                } else {
+                  Doc.nil;
+                },
                 print_expression(
                   ~expression_parent=GenericExpression,
                   ~original_source,
@@ -3032,25 +3064,11 @@ and print_expression_inner =
                       comments,
                     ),
                   e,
-                );
-              | Parsetree.PExpSpreadExpr =>
-                Doc.concat([
-                  Doc.text("..."),
-                  print_expression(
-                    ~expression_parent=GenericExpression,
-                    ~original_source,
-                    ~comments=
-                      Comment_utils.get_comments_inside_location(
-                        ~location=e.pexp_loc,
-                        comments,
-                      ),
-                    e,
-                  ),
-                ])
-              };
+                ),
+              ]);
             (expr, end_line_comments);
           },
-          collections,
+          flattened,
         );
 
       let (last_line_breaks_for_comments, list_items) =

compiler/src/parsing/ast_helper.re

@@ -431,12 +431,6 @@ module Expression = {
       switch (List.rev(a)) {
       | [] => empty
       | [base, ...rest] =>
-        let base =
-          switch (base) {
-          | ListItem(expr) =>
-            tuple_construct(~loc, ~attributes?, ident_cons, [expr, empty])
-          | ListSpread(expr, _) => expr
-          };
         let has_nonfinal_spread =
           List.exists(
             expr =>
@@ -447,29 +441,44 @@ module Expression = {
             rest,
           );
         if (has_nonfinal_spread) {
+          let base =
+            switch (base) {
+            | ListItem(expr) => (
+                PExpNonSpreadExpr,
+                tuple_construct(
+                  ~loc,
+                  ~attributes?,
+                  ident_cons,
+                  [expr, empty],
+                ),
+              )
+            | ListSpread(expr, _) => (PExpSpreadExpr, expr)
+            };
           let grouped =
             List.fold_left(
               (acc, expr) => {
                 switch (expr) {
                 | ListSpread(expr, loc) => [
-                    {...expr, pexp_loc: loc},
+                    (PExpSpreadExpr, {...expr, pexp_loc: loc}),
                     ...acc,
                   ]
                 | ListItem(expr) =>
-                  let (first, rest) =
-                    switch (acc) {
-                    | [first, ...rest] => (first, rest)
-                    | _ => assert(false)
-                    };
-                  [
-                    tuple_construct(
-                      ~loc,
-                      ~attributes?,
-                      ident_cons,
-                      [expr, first],
-                    ),
-                    ...rest,
-                  ];
+                  switch (acc) {
+                  | [(_, first), ...rest] => [
+                      (
+                        PExpNonSpreadExpr,
+                        tuple_construct(
+                          ~loc,
+                          ~attributes?,
+                          ident_cons,
+                          [expr, first],
+                        ),
+                      ),
+                      ...rest,
+                    ]
+                  | _ =>
+                    failwith("Impossible: processed ListItem with empty acc")
+                  }
                 }
               },
               [base],
@@ -479,9 +488,15 @@ module Expression = {
             ~loc,
             ~attributes?,
             PExpListConcat,
-            List.map(expr => (PExpSpreadExpr, expr), grouped),
+            grouped,
           );
         } else {
+          let base =
+            switch (base) {
+            | ListItem(expr) =>
+              tuple_construct(~loc, ~attributes?, ident_cons, [expr, empty])
+            | ListSpread(expr, _) => expr
+            };
           List.fold_left(
             (acc, expr) => {
               switch (expr) {

compiler/test/grainfmt/spreads.expected.gr

@@ -39,6 +39,7 @@ let rec reject2 = (fn, list) => {
 }
 
 let l = ["a", "b", "c"]
+let a = [...l, "a", "b", ...l, "d"]
 let a = [
   ...l,
   "secondInAVeryLongString",

compiler/test/grainfmt/spreads.input.gr

@@ -33,6 +33,7 @@ let rec reject2 = (fn, list) => {
 }
 
 let l = ["a", "b", "c"]
+let a = [...l, "a", "b", ...l, "d"]
 let a = [...l, "secondInAVeryLongString", "thirdInAStringThatWillBreakLine", ...l]
 
 let a = [

stdlib/runtime/concat.md

@@ -2,15 +2,19 @@
 title: Concat
 ---
 
+## Values
+
+Functions and constants included in the Concat module.
+
 ### Concat.**listConcat**
 
 ```grain
-listConcat : Array<List<a>> -> List<a>
+listConcat : (listsArray: Array<List<a>>) -> List<a>
 ```
 
 ### Concat.**arrayConcat**
 
 ```grain
-arrayConcat : Array<Array<a>> -> Array<a>
+arrayConcat : (arraysArray: Array<Array<a>>) -> Array<a>
 ```