Friendly error when using multiple spreads

Author: carlbordum

compiler-core/src/parse.rs

@@ -588,6 +588,15 @@ where
                                 elements_after_tail = Some(elements);
                             }
                         };
+
+                        // See if there is another spread
+                        // like `[..wibble, wobble, ..wabble]`
+                        if let Some((start, end)) = self.maybe_one(&Token::DotDot) {
+                          return parse_error(
+                              ParseErrorType::ListSpreadWithAnotherSpread,
+                              SrcSpan { start, end },
+                          );
+                        }
                     };
 
                     if tail.is_some() && !elements_end_with_comma {

compiler-core/src/parse/error.rs

@@ -157,6 +157,13 @@ utf16_codepoint, utf32_codepoint, signed, unsigned, big, little, native, size, u
                     "See: https://tour.gleam.run/basics/lists/".into(),
                 ],
             ),
+            ParseErrorType::ListSpreadWithAnotherSpread => (
+                "I wasn't expecting a spread here",
+                vec![
+                    "Hint: use list.append(list1, list2) to join two lists.".into(),
+                    "See: https://hexdocs.pm/gleam_stdlib/gleam/list.html#append".into(),
+                ],
+            ),
             ParseErrorType::ListSpreadFollowedByElements => (
                 "I wasn't expecting elements after this",
                 vec![
@@ -375,6 +382,7 @@ pub enum ParseErrorType {
     UnknownTarget, // an unknown target was used
     ListSpreadWithoutElements, // Pointless spread: `[..xs]`
     ListSpreadFollowedByElements, // trying to append something after the spread: `[..xs, x]`
+    ListSpreadWithAnotherSpread, // trying to use multiple spreads: `[..xs, ..ys]`
     LowcaseBooleanPattern, // most likely user meant True or False in patterns
     UnexpectedLabel, // argument labels were provided, but are not supported in this context
     UnexpectedEof,

compiler-core/src/parse/snapshots/gleam_core__parse__tests__list_spread_followed_by_another_spread.snap

@@ -0,0 +1,22 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\npub fn main() -> Nil {\n  let xs = [1, 2, 3]\n  let ys = [5, 6, 7]\n  [..xs, 4, ..ys]\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() -> Nil {
+  let xs = [1, 2, 3]
+  let ys = [5, 6, 7]
+  [..xs, 4, ..ys]
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:5:13
+  │
+5 │   [..xs, 4, ..ys]
+  │             ^^ I wasn't expecting a spread here
+
+Hint: use list.append(list1, list2) to join two lists.
+See: https://hexdocs.pm/gleam_stdlib/gleam/list.html#append

compiler-core/src/parse/tests.rs

@@ -363,6 +363,28 @@ fn pointless_spread() {
     );
 }
 
+#[test]
+fn double_spread() {
+    assert_error!(
+        "let xs = [1] let ys = [2, 3] [..xs, ..ys]",
+        ParseError {
+            error: ParseErrorType::ListSpreadWithAnotherSpread,
+            location: SrcSpan { start: 36, end: 38 },
+        }
+    );
+}
+
+#[test]
+fn double_spread2() {
+    assert_error!(
+        "let xs = [1] let ys = [3, 4] [..xs, 2, ..ys]",
+        ParseError {
+            error: ParseErrorType::ListSpreadWithAnotherSpread,
+            location: SrcSpan { start: 39, end: 41 },
+        }
+    );
+}
+
 // https://github.com/gleam-lang/gleam/issues/1358
 #[test]
 fn lowcase_bool_in_pattern() {
@@ -788,6 +810,19 @@ pub fn main() -> Nil {
     );
 }
 
+#[test]
+fn list_spread_followed_by_another_spread() {
+    assert_module_error!(
+        r#"
+pub fn main() -> Nil {
+  let xs = [1, 2, 3]
+  let ys = [5, 6, 7]
+  [..xs, 4, ..ys]
+}
+"#
+    );
+}
+
 #[test]
 fn list_spread_as_first_item_followed_by_other_items() {
     assert_module_error!(