Improve error message for custom type with fields but no constructor

CHANGELOG.md

@@ -490,6 +490,10 @@
   segments when compiling a function with a JavaScript external.
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- Fixed a bug where the compiler would produce a confusing error message when
+  writing a constructor with a lowercase name.
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 - A `gleam@@compile.erl` is no longer left in the build output of
   `gleam compile-package`.
   ([Louis Pilfold](https://github.com/lpil))

compiler-core/src/parse/error.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2020 The Gleam contributors
 
-use crate::ast::{SrcSpan, TypeAst};
+use crate::ast::{RecordConstructorArg, SrcSpan, TypeAst};
 use crate::diagnostic::{ExtraLabel, Label};
 use crate::error::{wrap, wrap_format};
 use crate::parse::Token;
@@ -145,12 +145,23 @@ pub enum ParseErrorType {
     RedundantInternalAttribute,          // for a private definition marked as internal
     InvalidModuleTypePattern,            // for patterns that have a dot like: `name.thing`
     ListPatternSpreadFollowedByElements, // When there is a pattern after a spread [..rest, pattern]
+
+    /// This happens when someone forgets to write the type constructor around
+    /// its fields in a custom type definition. For example:
+    ///
+    /// ```gleam
+    /// pub type Wibble {
+    ///   String,
+    ///   field: Int,
+    ///   field_2: a,
+    /// }
+    /// ```
     ExpectedRecordConstructor {
-        name: EcoString,
+        type_name: EcoString,
         public: bool,
         opaque: bool,
-        field: EcoString,
-        field_type: Option<Box<TypeAst>>,
+        /// Those are the fields that have been written.
+        fields: Vec<RecordConstructorArg<()>>,
     },
     CallInClauseGuard, // case x { _ if f() -> 1 }
     IfExpression,
@@ -684,34 +695,40 @@ See: https://tour.gleam.run/flow-control/case-expressions/"
             },
 
             ParseErrorType::ExpectedRecordConstructor {
-                name,
+                type_name,
                 public,
                 opaque,
-                field,
-                field_type,
+                fields,
             } => {
                 let (accessor, opaque) = match *public {
                     true if *opaque => ("pub ", "opaque "),
                     true => ("pub ", ""),
                     false => ("", ""),
                 };
 
-                let mut annotation = EcoString::new();
-                match field_type {
-                    Some(t) => t.print(&mut annotation),
-                    None => annotation.push_str("Type"),
-                };
+                let fields = fields
+                    .iter()
+                    .map(|field| {
+                        let mut type_ = EcoString::new();
+                        field.ast.print(&mut type_);
+
+                        match field.label.as_ref() {
+                            Some((_, label)) => format!("    {label}: {type_},"),
+                            None => format!("    {type_},"),
+                        }
+                    })
+                    .join("\n");
 
                 ParseErrorDetails {
-                    text: [
-                        "Each custom type variant must have a constructor:\n".into(),
-                        format!("{accessor}{opaque}type {name} {{"),
-                        format!("  {name}("),
-                        format!("    {field}: {annotation},"),
-                        "  )".into(),
-                        "}".into(),
-                    ]
-                    .join("\n"),
+                    text: format!(
+                        "Each custom type variant must have a constructor:
+
+{accessor}{opaque}type {type_name} {{
+  {type_name}(
+{fields}
+  )
+}}"
+                    ),
                     hint: None,
                     label_text: "I was not expecting this".into(),
                     extra_labels: vec![],

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

@@ -0,0 +1,20 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\npub type Wibble {\n  wibble(Int, String)\n}\n"
+---
+----- SOURCE CODE
+
+pub type Wibble {
+  wibble(Int, String)
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:3:3
+  │
+3 │   wibble(Int, String)
+  │   ^^^^^^ I'm expecting a type name here
+
+Hint: Type names start with a uppercase letter, and can contain a-z, A-Z,
+or 0-9.

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

@@ -0,0 +1,28 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: "\npub type Wibble(a) {\n  field: Int,\n  other: a\n}\n"
+---
+----- SOURCE CODE
+
+pub type Wibble(a) {
+  field: Int,
+  other: a
+}
+
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:3:3
+  │  
+3 │ ╭   field: Int,
+4 │ │   other: a
+  │ ╰──────────^ I was not expecting this
+
+Each custom type variant must have a constructor:
+
+pub type Wibble {
+  Wibble(
+    field: Int,
+    other: a,
+  )
+}

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

@@ -14,7 +14,7 @@ error: Syntax error
   ┌─ /src/parse/error.gleam:3:5
   │
 3 │     name: String,
-  │     ^^^^ I was not expecting this
+  │     ^^^^^^^^^^^^ I was not expecting this
 
 Each custom type variant must have a constructor:
 

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

@@ -14,12 +14,7 @@ error: Syntax error
   ┌─ /src/parse/error.gleam:3:5
   │
 3 │     name: "Test User",
-  │     ^^^^ I was not expecting this
+  │     ^^^^ I'm expecting a type name here
 
-Each custom type variant must have a constructor:
-
-type User {
-  User(
-    name: Type,
-  )
-}
+Hint: Type names start with a uppercase letter, and can contain a-z, A-Z,
+or 0-9.

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

@@ -20,6 +20,6 @@ Each custom type variant must have a constructor:
 
 pub opaque type User {
   User(
-    name: Type,
+    name,
   )
 }

compiler-core/src/parse/tests.rs

@@ -2510,3 +2510,26 @@ fn error_message_when_using_discard_pattern_for_as_pattern() {
 }"
     );
 }
+
+#[test]
+fn missing_constructor_name_with_multiple_fields() {
+    assert_module_error!(
+        r#"
+pub type Wibble(a) {
+  field: Int,
+  other: a
+}
+"#
+    );
+}
+
+#[test]
+fn lowercase_constructor_name_in_custom_type() {
+    assert_module_error!(
+        r#"
+pub type Wibble {
+  wibble(Int, String)
+}
+"#
+    );
+}