Add relevant suggestion when a type annotation uses angle brackets

Author: AaronC81

compiler-core/src/parse.rs

@@ -2564,7 +2564,7 @@ where
             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,
+                error: ParseErrorType::TypeDefinitionAngleGenerics,
                 location: SrcSpan {
                     start: less_start,
                     end: less_end,
@@ -2775,8 +2775,13 @@ where
                 arguments,
             })))
         } else if let Some((less_start, less_end)) = self.maybe_one(&Token::Less) {
+            let arguments = self.parse_types()?;
             Err(ParseError {
-                error: ParseErrorType::TypeAngleGenerics,
+                error: ParseErrorType::TypeUsageAngleGenerics {
+                    name,
+                    module: module.map(|(module_name, _)| module_name),
+                    arguments,
+                },
                 location: SrcSpan {
                     start: less_start,
                     end: less_end,

compiler-core/src/parse/error.rs

@@ -118,7 +118,14 @@ pub enum ParseErrorType {
     // When the use tries to define a constant inside a function
     ConstantInsideFunction,
     FunctionDefinitionAngleGenerics, // fn something<T>() { ... }
-    TypeAngleGenerics, // let a: List<String> = []
+    // let a: List<String> = []
+    TypeUsageAngleGenerics {
+        module: Option<EcoString>,
+        name: EcoString,
+        arguments: Vec<TypeAst>,
+    },
+    // type Something<T> {
+    TypeDefinitionAngleGenerics,
 }
 
 pub(crate) struct ParseErrorDetails {
@@ -669,7 +676,40 @@ See: https://tour.gleam.run/functions/generic-functions/"
                 extra_labels: vec![],
             },
 
-            ParseErrorType::TypeAngleGenerics => ParseErrorDetails {
+            ParseErrorType::TypeUsageAngleGenerics {
+                module,
+                name,
+                arguments,
+            } => {
+                let type_arguments = arguments
+                    .iter()
+                    .map(|argument| {
+                        let mut argument_string = EcoString::new();
+                        argument.print(&mut argument_string);
+                        argument_string
+                    })
+                    .join(", ");
+                let replacement_type = match module {
+                    Some(module) => format!("{module}.{name}({type_arguments})"),
+                    None => format!("{name}({type_arguments})"),
+                };
+
+                ParseErrorDetails {
+                    text: format!(
+                        "\
+Type parameters use lowercase names and are surrounded by parentheses.
+
+    {replacement_type}
+
+See: https://tour.gleam.run/data-types/generic-custom-types/"
+                    ),
+                    hint: None,
+                    label_text: "I was expecting `(` here.".into(),
+                    extra_labels: vec![],
+                }
+            }
+
+            ParseErrorType::TypeDefinitionAngleGenerics => ParseErrorDetails {
                 text: "\
 Type parameters use lowercase names and are surrounded by parentheses.
 

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

@@ -0,0 +1,19 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "let set: set.Set<Int> = set.new()"
+---
+----- SOURCE CODE
+let set: set.Set<Int> = set.new()
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:1:17
+  │
+1 │ let set: set.Set<Int> = set.new()
+  │                 ^ I was expecting `(` here.
+
+Type parameters use lowercase names and are surrounded by parentheses.
+
+    set.Set(Int)
+
+See: https://tour.gleam.run/data-types/generic-custom-types/

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

@@ -0,0 +1,19 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "let list: List<Int, String> = []"
+---
+----- SOURCE CODE
+let list: List<Int, String> = []
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:1:15
+  │
+1 │ let list: List<Int, String> = []
+  │               ^ I was expecting `(` here.
+
+Type parameters use lowercase names and are surrounded by parentheses.
+
+    List(Int, String)
+
+See: https://tour.gleam.run/data-types/generic-custom-types/

compiler-core/src/parse/tests.rs

@@ -1949,8 +1949,13 @@ fn function_definition_angle_generics_error() {
 }
 
 #[test]
-fn type_angle_generics_usage_error() {
-    assert_error!("let list: List<Int> = []");
+fn type_angle_generics_usage_without_module_error() {
+    assert_error!("let list: List<Int, String> = []");
+}
+
+#[test]
+fn type_angle_generics_usage_with_module_error() {
+    assert_error!("let set: set.Set<Int> = set.new()");
 }
 
 #[test]