Add specific parser error for type usages with angle-bracket generics

Author: AaronC81

compiler-core/src/parse.rs

@@ -2748,28 +2748,35 @@ where
         name: EcoString,
         end: u32,
     ) -> Result<Option<TypeAst>, ParseError> {
-        match self.maybe_one(&Token::LeftParen) {
-            Some((par_s, _)) => {
-                let arguments = self.parse_types()?;
-                let (_, par_e) = self.expect_one(&Token::RightParen)?;
-                if arguments.is_empty() {
-                    return parse_error(
-                        ParseErrorType::TypeConstructorNoArguments,
-                        SrcSpan::new(par_s, par_e),
-                    );
-                }
-                Ok(Some(TypeAst::Constructor(TypeAstConstructor {
-                    location: SrcSpan { start, end: par_e },
-                    name_location: SrcSpan {
-                        start: name_start,
-                        end,
-                    },
-                    module,
-                    name,
-                    arguments,
-                })))
+        if let Some((par_s, _)) = self.maybe_one(&Token::LeftParen) {
+            let arguments = self.parse_types()?;
+            let (_, par_e) = self.expect_one(&Token::RightParen)?;
+            if arguments.is_empty() {
+                return parse_error(
+                    ParseErrorType::TypeConstructorNoArguments,
+                    SrcSpan::new(par_s, par_e),
+                );
             }
-            _ => Ok(Some(TypeAst::Constructor(TypeAstConstructor {
+            Ok(Some(TypeAst::Constructor(TypeAstConstructor {
+                location: SrcSpan { start, end: par_e },
+                name_location: SrcSpan {
+                    start: name_start,
+                    end,
+                },
+                module,
+                name,
+                arguments,
+            })))
+        } 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(Some(TypeAst::Constructor(TypeAstConstructor {
                 location: SrcSpan { start, end },
                 name_location: SrcSpan {
                     start: name_start,
@@ -2778,7 +2785,7 @@ where
                 module,
                 name,
                 arguments: vec![],
-            }))),
+            })))
         }
     }
 

compiler-core/src/parse/error.rs

@@ -118,6 +118,7 @@ pub enum ParseErrorType {
     // When the use tries to define a constant inside a function
     ConstantInsideFunction,
     FunctionDefinitionAngleGenerics, // fn something<T>() { ... }
+    TypeAngleGenerics, // let a: List<String> = []
 }
 
 pub(crate) struct ParseErrorDetails {
@@ -667,6 +668,19 @@ See: https://tour.gleam.run/functions/generic-functions/"
                 label_text: "I was expecting `(` here.".into(),
                 extra_labels: vec![],
             },
+
+            ParseErrorType::TypeAngleGenerics => ParseErrorDetails {
+                text: "\
+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/".into(),
+                hint: None,
+                label_text: "I was expecting `(` here.".into(),
+                extra_labels: vec![],
+            },
         }
     }
 }

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

@@ -0,0 +1,20 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "let list: List<Int> = []"
+---
+----- SOURCE CODE
+let list: List<Int> = []
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:1:15
+  │
+1 │ let list: List<Int> = []
+  │               ^ 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/tests.rs

@@ -1947,3 +1947,8 @@ pub fn main() {
 fn function_definition_angle_generics_error() {
     assert_module_error!("fn id<T>(x: T) { x }");
 }
+
+#[test]
+fn type_angle_generics_error() {
+    assert_error!("let list: List<Int> = []");
+}