Spread anywhere feature

src/res_core.ml

@@ -81,15 +81,6 @@ module ErrorMessages = struct
      ...b}` wouldn't make sense, as `b` would override every field of `a` \
      anyway."
 
-  let listExprSpread =
-    "Lists can only have one `...` spread, and at the end.\n\
-     Explanation: lists are singly-linked list, where a node contains a value \
-     and points to the next node. `list{a, ...bc}` efficiently creates a new \
-     item and links `bc` as its next nodes. `list{...bc, a}` would be \
-     expensive, as it'd need to traverse `bc` and prepend each item to `a` one \
-     by one. We therefore disallow such syntax sugar.\n\
-     Solution: directly use `concat`."
-
   let variantIdent =
     "A polymorphic variant (e.g. #id) must start with an alphabetical letter \
      or be a number (e.g. #742)"
@@ -3705,38 +3696,66 @@ and parseTupleExpr ~first ~startPos p =
   let loc = mkLoc startPos p.prevEndPos in
   Ast_helper.Exp.tuple ~loc exprs
 
-and parseSpreadExprRegion p =
+and parseSpreadExprRegionWithLoc p =
+  let startPos = p.Parser.prevEndPos in
   match p.Parser.token with
   | DotDotDot ->
     Parser.next p;
     let expr = parseConstrainedOrCoercedExpr p in
-    Some (true, expr)
+    Some (true, expr, startPos, p.prevEndPos)
   | token when Grammar.isExprStart token ->
-    Some (false, parseConstrainedOrCoercedExpr p)
+    Some (false, parseConstrainedOrCoercedExpr p, startPos, p.prevEndPos)
   | _ -> None
 
 and parseListExpr ~startPos p =
-  let check_all_non_spread_exp exprs =
-    exprs
-    |> List.map (fun (spread, expr) ->
-           if spread then
-             Parser.err p (Diagnostics.message ErrorMessages.listExprSpread);
-           expr)
-    |> List.rev
+  let split_by_spread exprs =
+    List.fold_left
+      (fun acc curr ->
+        match (curr, acc) with
+        | (true, expr, startPos, endPos), _ ->
+          (* find a spread expression, prepend a new sublist *)
+          ([], Some expr, startPos, endPos) :: acc
+        | ( (false, expr, startPos, _endPos),
+            (no_spreads, spread, _accStartPos, accEndPos) :: acc ) ->
+          (* find a non-spread expression, and the accumulated is not empty,
+           * prepend to the first sublist, and update the loc first sublist *)
+          (expr :: no_spreads, spread, startPos, accEndPos) :: acc
+        | (false, expr, startPos, endPos), [] ->
+          (* find a non-spread expression, and the accumulated is empty *)
+          [([expr], None, startPos, endPos)])
+      [] exprs
+  in
+  let make_sub_expr = function
+    | exprs, Some spread, startPos, endPos ->
+      makeListExpression (mkLoc startPos endPos) exprs (Some spread)
+    | exprs, None, startPos, endPos ->
+      makeListExpression (mkLoc startPos endPos) exprs None
   in
   let listExprsRev =
     parseCommaDelimitedReversedList p ~grammar:Grammar.ListExpr ~closing:Rbrace
-      ~f:parseSpreadExprRegion
+      ~f:parseSpreadExprRegionWithLoc
   in
   Parser.expect Rbrace p;
   let loc = mkLoc startPos p.prevEndPos in
-  match listExprsRev with
-  | (true (* spread expression *), expr) :: exprs ->
-    let exprs = check_all_non_spread_exp exprs in
-    makeListExpression loc exprs (Some expr)
+  match split_by_spread listExprsRev with
+  | [] -> makeListExpression loc [] None
+  | [(exprs, Some spread, _, _)] -> makeListExpression loc exprs (Some spread)
+  | [(exprs, None, _, _)] -> makeListExpression loc exprs None
   | exprs ->
-    let exprs = check_all_non_spread_exp exprs in
-    makeListExpression loc exprs None
+    let listExprs = List.map make_sub_expr exprs in
+    Ast_helper.Exp.apply ~loc
+      (Ast_helper.Exp.ident ~loc
+         (Location.mkloc
+            (Longident.Ldot
+               (Longident.Ldot (Longident.Lident "Belt", "List"), "concatMany"))
+            loc))
+      [(Asttypes.Nolabel, Ast_helper.Exp.array ~loc listExprs)]
+(* | (true (\* spread expression *\), expr, _) :: exprs ->
+ *   let exprs = check_all_non_spread_exp exprs in
+ *   makeListExpression loc exprs (Some expr)
+ * | exprs ->
+ *   let exprs = check_all_non_spread_exp exprs in
+ *   makeListExpression loc exprs None *)
 
 (* Overparse ... and give a nice error message *)
 and parseNonSpreadExp ~msg p =

tests/parsing/errors/other/expected/spread.res.txt

@@ -49,20 +49,6 @@ Explanation: you can't collect a subset of a record's field into its own record,
 Solution: you need to pull out each field you want explicitly.
 
 
-  Syntax error!
-  tests/parsing/errors/other/spread.res:8:1-3
-
-   6 │ 
-   7 │ let myList = list{...x, ...y}
-   8 │ let list{...x, ...y} = myList
-   9 │ 
-  10 │ type t = {...a}
-
-  Lists can only have one `...` spread, and at the end.
-Explanation: lists are singly-linked list, where a node contains a value and points to the next node. `list{a, ...bc}` efficiently creates a new item and links `bc` as its next nodes. `list{...bc, a}` would be expensive, as it'd need to traverse `bc` and prepend each item to `a` one by one. We therefore disallow such syntax sugar.
-Solution: directly use `concat`.
-
-
   Syntax error!
   tests/parsing/errors/other/spread.res:8:13-22
 
@@ -114,7 +100,7 @@ let arr = [|x;y|]
 let [|arr;_|] = [|1;2;3|]
 let record = { x with y }
 let { x; y } = myRecord
-let myList = x :: y
+let myList = Belt.List.concatMany [|x;y|]
 let x::y = myList
 type nonrec t = < a  > 
 type nonrec t =

tests/parsing/grammar/expressions/expected/list.res.txt

@@ -3,4 +3,5 @@ let x = [1; 2; 3]
 let x = [1; 2; 3]
 let x = [(1 : int); (2 : int); (3 : int)]
 let x = 4 :: 5 :: y
+let x = Belt.List.concatMany [|(1 :: x);(2 :: 3 :: x)|]
 let x = 1 :: 2 :: (y : int list)

tests/parsing/grammar/expressions/list.res

@@ -12,5 +12,8 @@ let x = list{1: int, (2: int), 3: int}
 // spread
 let x = list{4, 5, ...y}
 
+// spread anywhere
+let x = list{1, ...x, 2, 3, ...x}
+
 // spread constrained expression
 let x = list{1, 2, ...y: list<int>}

tests/printer/expr/expected/list.res.txt

@@ -2,6 +2,7 @@ let x = list{}
 let x = list{1}
 let x = list{1, 2}
 let x = list{1, 2, 3}
+let x = Belt.List.concatMany([list{1, 2, ...x}, list{3, ...x}])
 
 let x = list{
   superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
@@ -17,3 +18,15 @@ let x = list{
   superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
   ...superLoooooooooooooooooooooooooooooongListHere,
 }
+
+let x = Belt.List.concatMany([
+  list{
+    superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
+    superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
+    ...superLoooooooooooooooooooooooooooooongListHere,
+  },
+  list{
+    superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
+    ...superLoooooooooooooooooooooooooooooongListHere,
+  },
+])

tests/printer/expr/list.res

@@ -2,6 +2,7 @@ let x = list{}
 let x = list{1}
 let x = list{1, 2}
 let x = list{1, 2, 3}
+let x = list{1, 2, ...x, 3, ...x}
 
 let x = list{
   superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
@@ -18,3 +19,13 @@ let x = list{
   superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
   ...superLoooooooooooooooooooooooooooooongListHere,
 }
+
+
+
+
+let x = list{
+  superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
+  superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer, ...superLoooooooooooooooooooooooooooooongListHere,
+  superLoooooooooooooooooooooooooooooongIiiiiiiiiideeeentifieeeeeeeeeeeeeeeeer,
+  ...superLoooooooooooooooooooooooooooooongListHere,
+}