Array spread syntax support (#6608)

* Implement parser to get spread expressions

* Flatten array and call concatMany just once

* Remove empty array in the parser output

* Implement spread array printer

* Update array parsing tests

* Clean up

* Fix tests

* Fix extra whitespace got deleted by editor and run ocamlformat

* Update changelog

Author: shulhi

CHANGELOG.md

@@ -30,6 +30,7 @@
 - Experimental support of tagged template literals, e.g. ```sql`select * from ${table}```. https://github.com/rescript-lang/rescript-compiler/pull/6250
 - Experimental support for generic/custom JSX transforms. https://github.com/rescript-lang/rescript-compiler/pull/6565
 - `dict` is now a builtin type. https://github.com/rescript-lang/rescript-compiler/pull/6590
+- Add support for array spread. https://github.com/rescript-lang/rescript-compiler/pull/6608
 
 #### :bug: Bug Fix
 

jscomp/syntax/src/res_core.ml

@@ -78,10 +78,6 @@ module ErrorMessages = struct
      + Array size check + `get` checks on the current pattern. If it's to \
      obtain a subarray, use `Array.sub` or `Belt.Array.slice`."
 
-  let arrayExprSpread =
-    "Arrays can't use the `...` spread currently. Please use `concat` or other \
-     Array helpers."
-
   let recordExprSpread =
     "Records can only have one `...` spread, at the beginning.\n\
      Explanation: since records have a known, fixed shape, a spread like `{a, \
@@ -3920,36 +3916,60 @@ and parseListExpr ~startPos p =
             loc))
       [(Asttypes.Nolabel, Ast_helper.Exp.array ~loc listExprs)]
 
-(* Overparse ... and give a nice error message *)
-and parseNonSpreadExp ~msg p =
-  let () =
-    match p.Parser.token with
-    | DotDotDot ->
-      Parser.err p (Diagnostics.message msg);
-      Parser.next p
-    | _ -> ()
-  in
-  match p.Parser.token with
-  | token when Grammar.isExprStart token -> (
-    let expr = parseExpr p in
-    match p.Parser.token with
-    | Colon ->
-      Parser.next p;
-      let typ = parseTypExpr p in
-      let loc = mkLoc expr.pexp_loc.loc_start typ.ptyp_loc.loc_end in
-      Some (Ast_helper.Exp.constraint_ ~loc expr typ)
-    | _ -> Some expr)
-  | _ -> None
-
 and parseArrayExp p =
   let startPos = p.Parser.startPos in
   Parser.expect Lbracket p;
-  let exprs =
-    parseCommaDelimitedRegion p ~grammar:Grammar.ExprList ~closing:Rbracket
-      ~f:(parseNonSpreadExp ~msg:ErrorMessages.arrayExprSpread)
+  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 of the 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 listExprsRev =
+    parseCommaDelimitedReversedList p ~grammar:Grammar.ExprList
+      ~closing:Rbracket ~f:parseSpreadExprRegionWithLoc
   in
   Parser.expect Rbracket p;
-  Ast_helper.Exp.array ~loc:(mkLoc startPos p.prevEndPos) exprs
+  let loc = mkLoc startPos p.prevEndPos in
+  let collectExprs = function
+    | [], Some spread, _startPos, _endPos -> [spread]
+    | exprs, Some spread, _startPos, _endPos ->
+      let els = Ast_helper.Exp.array ~loc exprs in
+      [els; spread]
+    | exprs, None, _startPos, _endPos ->
+      let els = Ast_helper.Exp.array ~loc exprs in
+      [els]
+  in
+  match split_by_spread listExprsRev with
+  | [] -> Ast_helper.Exp.array ~loc:(mkLoc startPos p.prevEndPos) []
+  | [(exprs, None, _, _)] ->
+    Ast_helper.Exp.array ~loc:(mkLoc startPos p.prevEndPos) exprs
+  | exprs ->
+    let xs = List.map collectExprs exprs in
+    let listExprs =
+      List.fold_right
+        (fun exprs1 acc ->
+          List.fold_right (fun expr1 acc1 -> expr1 :: acc1) exprs1 acc)
+        xs []
+    in
+    Ast_helper.Exp.apply ~loc
+      (Ast_helper.Exp.ident ~loc ~attrs:[spreadAttr]
+         (Location.mkloc
+            (Longident.Ldot
+               (Longident.Ldot (Longident.Lident "Belt", "Array"), "concatMany"))
+            loc))
+      [(Asttypes.Nolabel, Ast_helper.Exp.array ~loc listExprs)]
 
 (* TODO: check attributes in the case of poly type vars,
  * might be context dependend: parseFieldDeclaration (see ocaml) *)

jscomp/syntax/src/res_parsetree_viewer.ml

@@ -104,6 +104,11 @@ let hasAwaitAttribute attrs =
       | _ -> false)
     attrs
 
+let collectArrayExpressions expr =
+  match expr.pexp_desc with
+  | Pexp_array exprs -> (exprs, None)
+  | _ -> ([], Some expr)
+
 let collectListExpressions expr =
   let rec collect acc expr =
     match expr.pexp_desc with
@@ -678,6 +683,17 @@ let isSpreadBeltListConcat expr =
     hasSpreadAttr expr.pexp_attributes
   | _ -> false
 
+let isSpreadBeltArrayConcat expr =
+  match expr.pexp_desc with
+  | Pexp_ident
+      {
+        txt =
+          Longident.Ldot
+            (Longident.Ldot (Longident.Lident "Belt", "Array"), "concatMany");
+      } ->
+    hasSpreadAttr expr.pexp_attributes
+  | _ -> false
+
 (* Blue | Red | Green -> [Blue; Red; Green] *)
 let collectOrPatternChain pat =
   let rec loop pattern chain =

jscomp/syntax/src/res_parsetree_viewer.mli

@@ -46,6 +46,10 @@ val collectIfExpressions :
   (Location.t * ifConditionKind * Parsetree.expression) list
   * Parsetree.expression option
 
+val collectArrayExpressions :
+  Parsetree.expression ->
+  Parsetree.expression list * Parsetree.expression option
+
 val collectListExpressions :
   Parsetree.expression ->
   Parsetree.expression list * Parsetree.expression option
@@ -142,6 +146,8 @@ val hasTemplateLiteralAttr : Parsetree.attributes -> bool
 
 val isSpreadBeltListConcat : Parsetree.expression -> bool
 
+val isSpreadBeltArrayConcat : Parsetree.expression -> bool
+
 val collectOrPatternChain : Parsetree.pattern -> Parsetree.pattern list
 
 val processBracesAttr :

jscomp/syntax/src/res_printer.ml

@@ -3046,6 +3046,9 @@ and printExpression ~state (e : Parsetree.expression) cmtTbl =
                Doc.rbrace;
              ])
       | extension -> printExtension ~state ~atModuleLvl:false extension cmtTbl)
+    | Pexp_apply (e, [(Nolabel, {pexp_desc = Pexp_array subLists})])
+      when ParsetreeViewer.isSpreadBeltArrayConcat e ->
+      printBeltArrayConcatApply ~state subLists cmtTbl
     | Pexp_apply (e, [(Nolabel, {pexp_desc = Pexp_array subLists})])
       when ParsetreeViewer.isSpreadBeltListConcat e ->
       printBeltListConcatApply ~state subLists cmtTbl
@@ -3813,6 +3816,61 @@ and printBinaryExpression ~state (expr : Parsetree.expression) cmtTbl =
          ])
   | _ -> Doc.nil
 
+and printBeltArrayConcatApply ~state subLists cmtTbl =
+  let makeSpreadDoc commaBeforeSpread = function
+    | Some expr ->
+      Doc.concat
+        [
+          commaBeforeSpread;
+          Doc.dotdotdot;
+          (let doc = printExpressionWithComments ~state expr cmtTbl in
+           match Parens.expr expr with
+           | Parens.Parenthesized -> addParens doc
+           | Braced braces -> printBraces doc expr braces
+           | Nothing -> doc);
+        ]
+    | None -> Doc.nil
+  in
+  let makeSubListDoc (expressions, spread) =
+    let commaBeforeSpread =
+      match expressions with
+      | [] -> Doc.nil
+      | _ -> Doc.concat [Doc.text ","; Doc.line]
+    in
+    let spreadDoc = makeSpreadDoc commaBeforeSpread spread in
+    Doc.concat
+      [
+        Doc.join
+          ~sep:(Doc.concat [Doc.text ","; Doc.line])
+          (List.map
+             (fun expr ->
+               let doc = printExpressionWithComments ~state expr cmtTbl in
+               match Parens.expr expr with
+               | Parens.Parenthesized -> addParens doc
+               | Braced braces -> printBraces doc expr braces
+               | Nothing -> doc)
+             expressions);
+        spreadDoc;
+      ]
+  in
+  Doc.group
+    (Doc.concat
+       [
+         Doc.lbracket;
+         Doc.indent
+           (Doc.concat
+              [
+                Doc.softLine;
+                Doc.join
+                  ~sep:(Doc.concat [Doc.text ","; Doc.line])
+                  (List.map makeSubListDoc
+                     (List.map ParsetreeViewer.collectArrayExpressions subLists));
+              ]);
+         Doc.trailingComma;
+         Doc.softLine;
+         Doc.rbracket;
+       ])
+
 and printBeltListConcatApply ~state subLists cmtTbl =
   let makeSpreadDoc commaBeforeSpread = function
     | Some expr ->

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

@@ -1,79 +1,67 @@
 
   Syntax error!
-  tests/parsing/errors/other/spread.res:1:12-14
+  tests/parsing/errors/other/spread.res:1:6-8
 
-  1 │ let arr = [...x, ...y]
-  2 │ let [...arr, _] = [1, 2, 3]
-  3 │ 
-
-  Arrays can't use the `...` spread currently. Please use `concat` or other Array helpers.
-
-
-  Syntax error!
-  tests/parsing/errors/other/spread.res:2:6-8
-
-  1 │ let arr = [...x, ...y]
-  2 │ let [...arr, _] = [1, 2, 3]
-  3 │ 
-  4 │ let record = {...x, ...y}
+  1 │ let [...arr, _] = [1, 2, 3]
+  2 │ 
+  3 │ let record = {...x, ...y}
 
   Array's `...` spread is not supported in pattern matches.
 Explanation: such spread would create a subarray; out of performance concern, our pattern matching currently guarantees to never create new intermediate data.
 Solution: if it's to validate the first few elements, use a `when` clause + Array size check + `get` checks on the current pattern. If it's to obtain a subarray, use `Array.sub` or `Belt.Array.slice`.
 
 
   Syntax error!
-  tests/parsing/errors/other/spread.res:4:21-23
+  tests/parsing/errors/other/spread.res:3:21-23
 
-  2 │ let [...arr, _] = [1, 2, 3]
-  3 │ 
-  4 │ let record = {...x, ...y}
-  5 │ let {...x, ...y} = myRecord
-  6 │ 
+  1 │ let [...arr, _] = [1, 2, 3]
+  2 │ 
+  3 │ let record = {...x, ...y}
+  4 │ let {...x, ...y} = myRecord
+  5 │ 
 
   Records can only have one `...` spread, at the beginning.
 Explanation: since records have a known, fixed shape, a spread like `{a, ...b}` wouldn't make sense, as `b` would override every field of `a` anyway.
 
 
   Syntax error!
-  tests/parsing/errors/other/spread.res:5:15-18
+  tests/parsing/errors/other/spread.res:4:15-18
 
-  3 │ 
-  4 │ let record = {...x, ...y}
-  5 │ let {...x, ...y} = myRecord
-  6 │ 
-  7 │ let list{...x, ...y} = myList
+  2 │ 
+  3 │ let record = {...x, ...y}
+  4 │ let {...x, ...y} = myRecord
+  5 │ 
+  6 │ let list{...x, ...y} = myList
 
   Record's `...` spread is not supported in pattern matches.
 Explanation: you can't collect a subset of a record's field into its own record, since a record needs an explicit declaration and that subset wouldn't have one.
 Solution: you need to pull out each field you want explicitly.
 
 
   Syntax error!
-  tests/parsing/errors/other/spread.res:7:13-22
+  tests/parsing/errors/other/spread.res:6:13-22
 
-  5 │ let {...x, ...y} = myRecord
-  6 │ 
-  7 │ let list{...x, ...y} = myList
-  8 │ 
-  9 │ type t = {...a}
+  4 │ let {...x, ...y} = myRecord
+  5 │ 
+  6 │ let list{...x, ...y} = myList
+  7 │ 
+  8 │ type t = {...a}
 
   List pattern matches only supports one `...` spread, at the end.
 Explanation: a list spread at the tail is efficient, but a spread in the middle would create new lists; out of performance concern, our pattern matching currently guarantees to never create new intermediate data.
 
 
   Syntax error!
-  tests/parsing/errors/other/spread.res:10:20
+  tests/parsing/errors/other/spread.res:9:20
 
-   8 │ 
-   9 │ type t = {...a}
-  10 │ type t = Foo({...a})
-  11 │ type t = option<foo, {...x}>
-  12 │ 
+   7 │ 
+   8 │ type t = {...a}
+   9 │ type t = Foo({...a})
+  10 │ type t = option<foo, {...x}>
+  11 │ 
 
   I'm not sure what to parse here when looking at ")".
 
-let arr = [|x;y|]
 let [|arr;_|] = [|1;2;3|]
 let record = { x with y }
 let { x; y } = myRecord

jscomp/syntax/tests/parsing/errors/other/spread.res

@@ -1,4 +1,3 @@
-let arr = [...x, ...y]
 let [...arr, _] = [1, 2, 3]
 
 let record = {...x, ...y}

jscomp/syntax/tests/parsing/grammar/expressions/array.res

@@ -5,3 +5,18 @@ let x = [1, 2, 3,]
 
 // with constrained expressions
 let x = [1 :int, (2: int), 3 : int]
+
+// spread
+let x = [4, 5, ...y]
+
+// spread anywhere
+let x = [4, 5, ...y, 7, ...y]
+
+// spread constrained expressions
+let x = [4, 5, ...y: array<int>]
+
+// spread with other variable
+let x = [4, 5, k, ...y]
+
+// the only spread
+let x = [...y]

jscomp/syntax/tests/parsing/grammar/expressions/expected/array.res.txt

@@ -1,3 +1,8 @@
 let x = [|1;2;3|]
 let x = [|1;2;3|]
-let x = [|(1 : int);(2 : int);(3 : int)|]
+let x = [|(1 : int);(2 : int);(3 : int)|]
+let x = ((Belt.Array.concatMany)[@res.spread ]) [|[|4;5|];y|]
+let x = ((Belt.Array.concatMany)[@res.spread ]) [|[|4;5|];y;[|7|];y|]
+let x = ((Belt.Array.concatMany)[@res.spread ]) [|[|4;5|];(y : int array)|]
+let x = ((Belt.Array.concatMany)[@res.spread ]) [|[|4;5;k|];y|]
+let x = ((Belt.Array.concatMany)[@res.spread ]) [|y|]

jscomp/syntax/tests/parsing/recovery/expression/expected/list.res.txt

@@ -33,7 +33,8 @@ let flags =
         let rec loop items =
           ((match items with
             | [|{js|-pp|js};_ppFlag;rest|] -> loop rest
-            | [|x;rest|] -> [|x;(loop rest)|]
+            | [|x;rest|] ->
+                ((Belt.Array.concatMany)[@res.spread ]) [|[|x|];(loop rest)|]
             | [||] -> [||])
           [@res.braces ]) in
         (loop parts) |> (String.concat {js| |js}))