Extend type angle-bracket generics errors to cover type definitions

Author: AaronC81

compiler-core/src/parse.rs

@@ -2547,24 +2547,31 @@ where
         &mut self,
     ) -> Result<(u32, EcoString, Vec<SpannedString>, u32, u32), ParseError> {
         let (start, upname, end) = self.expect_upname()?;
-        match self.maybe_one(&Token::LeftParen) {
-            Some((par_s, _)) => {
-                let arguments =
-                    Parser::series_of(self, &|p| Ok(Parser::maybe_name(p)), Some(&Token::Comma))?;
-                let (_, par_e) = self.expect_one_following_series(&Token::RightParen, "a name")?;
-                if arguments.is_empty() {
-                    return parse_error(
-                        ParseErrorType::TypeDefinitionNoArguments,
-                        SrcSpan::new(par_s, par_e),
-                    );
-                }
-                let arguments2 = arguments
-                    .into_iter()
-                    .map(|(start, name, end)| (SrcSpan { start, end }, name))
-                    .collect();
-                Ok((start, upname, arguments2, par_e, end))
+        if let Some((par_s, _)) = self.maybe_one(&Token::LeftParen) {
+            let arguments =
+                Parser::series_of(self, &|p| Ok(Parser::maybe_name(p)), Some(&Token::Comma))?;
+            let (_, par_e) = self.expect_one_following_series(&Token::RightParen, "a name")?;
+            if arguments.is_empty() {
+                return parse_error(
+                    ParseErrorType::TypeDefinitionNoArguments,
+                    SrcSpan::new(par_s, par_e),
+                );
             }
-            _ => Ok((start, upname, vec![], end, end)),
+            let arguments2 = arguments
+                .into_iter()
+                .map(|(start, name, end)| (SrcSpan { start, end }, name))
+                .collect();
+            Ok((start, upname, arguments2, par_e, end))
+        } else if let Some((less_start, less_end)) = self.maybe_one(&Token::Less) {
+            Err(ParseError {
+                error: ParseErrorType::TypeAngleGenerics,
+                location: SrcSpan {
+                    start: less_start,
+                    end: less_end,
+                },
+            })
+        } else {
+            Ok((start, upname, vec![], end, end))
         }
     }
 

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

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

compiler-core/src/parse/snapshots/gleam_core__parse__tests__type_angle_generics_error.snap renamed to compiler-core/src/parse/snapshots/gleam_core__parse__tests__type_angle_generics_usage_error.snap

@@ -1949,6 +1949,18 @@ fn function_definition_angle_generics_error() {
 }
 
 #[test]
-fn type_angle_generics_error() {
+fn type_angle_generics_usage_error() {
     assert_error!("let list: List<Int> = []");
 }
+
+#[test]
+fn type_angle_generics_definition_error() {
+    assert_module_error!(
+        r#"
+type Maybe<A> {
+    Some(A)
+    None
+}
+"#
+    );
+}