Add relevant suggestion when a type definition uses angle brackets

Author: AaronC81

compiler-core/src/parse.rs

@@ -2563,8 +2563,29 @@ where
                 .collect();
             Ok((start, upname, arguments2, par_e, end))
         } else if let Some((less_start, less_end)) = self.maybe_one(&Token::Less) {
+            let mut arguments = Parser::series_of(
+                self,
+                &|p|
+                        // Permit either names (`a`) or upnames (`A`) in this error-handling mode,
+                        // as upnames are common in other languages. Convert to lowercase so the
+                        // example is correct whichever was used.
+                        Ok(Parser::maybe_name(p)
+                            .or_else(|| Parser::maybe_upname(p))
+                            .map(|(_, name, _)| name.to_lowercase())),
+                Some(&Token::Comma),
+            )?;
+
+            // If no type arguments were parsed, fall back to a dummy type argument as an example,
+            // because `Type()` would be invalid
+            if arguments.is_empty() {
+                arguments = vec!["value".into()];
+            }
+
             Err(ParseError {
-                error: ParseErrorType::TypeDefinitionAngleGenerics,
+                error: ParseErrorType::TypeDefinitionAngleGenerics {
+                    name: upname,
+                    arguments: arguments,
+                },
                 location: SrcSpan {
                     start: less_start,
                     end: less_end,

compiler-core/src/parse/error.rs

@@ -125,7 +125,10 @@ pub enum ParseErrorType {
         arguments: Vec<TypeAst>,
     },
     // type Something<T> {
-    TypeDefinitionAngleGenerics,
+    TypeDefinitionAngleGenerics {
+        name: EcoString,
+        arguments: Vec<EcoString>,
+    },
 }
 
 pub(crate) struct ParseErrorDetails {
@@ -709,18 +712,23 @@ See: https://tour.gleam.run/data-types/generic-custom-types/"
                 }
             }
 
-            ParseErrorType::TypeDefinitionAngleGenerics => ParseErrorDetails {
-                text: "\
+            ParseErrorType::TypeDefinitionAngleGenerics { name, arguments } => {
+                let comma_separated_arguments = arguments.join(", ");
+
+                ParseErrorDetails {
+                    text: format!(
+                        "\
 Type parameters use lowercase names and are surrounded by parentheses.
 
-    List(String)
-    Result(Int, Error)
+    type {name}({comma_separated_arguments}) {{
 
-See: https://tour.gleam.run/data-types/generic-custom-types/".into(),
-                hint: None,
-                label_text: "I was expecting `(` here.".into(),
-                extra_labels: vec![],
-            },
+See: https://tour.gleam.run/data-types/generic-custom-types/"
+                    ),
+                    hint: None,
+                    label_text: "I was expecting `(` here.".into(),
+                    extra_labels: vec![],
+                }
+            }
         }
     }
 }

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

@@ -1,25 +1,24 @@
 ---
 source: compiler-core/src/parse/tests.rs
-expression: "\ntype Maybe<A> {\n    Some(A)\n    None\n}\n"
+expression: "\ntype Either<a, b> {\n    This(a)\n    That(b)\n}\n"
 ---
 ----- SOURCE CODE
 
-type Maybe<A> {
-    Some(A)
-    None
+type Either<a, b> {
+    This(a)
+    That(b)
 }
 
 
 ----- ERROR
 error: Syntax error
-  ┌─ /src/parse/error.gleam:2:11
+  ┌─ /src/parse/error.gleam:2:12
   │
-2 │ type Maybe<A> {
-  │           ^ I was expecting `(` here.
+2 │ type Either<a, b> {
+  │            ^ I was expecting `(` here.
 
 Type parameters use lowercase names and are surrounded by parentheses.
 
-    List(String)
-    Result(Int, Error)
+    type Either(a, b) {
 
 See: https://tour.gleam.run/data-types/generic-custom-types/

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

@@ -0,0 +1,24 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\ntype Either<type A, type B> {\n    This(A)\n    That(B)\n}\n"
+---
+----- SOURCE CODE
+
+type Either<type A, type B> {
+    This(A)
+    That(B)
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:2:12
+  │
+2 │ type Either<type A, type B> {
+  │            ^ I was expecting `(` here.
+
+Type parameters use lowercase names and are surrounded by parentheses.
+
+    type Either(value) {
+
+See: https://tour.gleam.run/data-types/generic-custom-types/

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

@@ -0,0 +1,24 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\ntype Either<A, B> {\n    This(A)\n    That(B)\n}\n"
+---
+----- SOURCE CODE
+
+type Either<A, B> {
+    This(A)
+    That(B)
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:2:12
+  │
+2 │ type Either<A, B> {
+  │            ^ I was expecting `(` here.
+
+Type parameters use lowercase names and are surrounded by parentheses.
+
+    type Either(a, b) {
+
+See: https://tour.gleam.run/data-types/generic-custom-types/

compiler-core/src/parse/tests.rs

@@ -1962,9 +1962,35 @@ fn type_angle_generics_usage_with_module_error() {
 fn type_angle_generics_definition_error() {
     assert_module_error!(
         r#"
-type Maybe<A> {
-    Some(A)
-    None
+type Either<a, b> {
+    This(a)
+    That(b)
+}
+"#
+    );
+}
+
+#[test]
+fn type_angle_generics_definition_with_upname_error() {
+    assert_module_error!(
+        r#"
+type Either<A, B> {
+    This(A)
+    That(B)
+}
+"#
+    );
+}
+
+#[test]
+fn type_angle_generics_definition_error_fallback() {
+    // Example of a more incorrect syntax, where Gleam doesn't make a suggestion.
+    // In this case, an example type argument is used instead.
+    assert_module_error!(
+        r#"
+type Either<type A, type B> {
+    This(A)
+    That(B)
 }
 "#
     );