Preserve generic type parameters when constructors or functions are used without explicit annotations

Closes #2533, #2550

Author: abs0luty

CHANGELOG.md

@@ -34,6 +34,37 @@
   than stopping at the syntax error.
   ([mxtthias](https://github.com/mxtthias))
 
+- Type inference now preserves generic type parameters when constructors or functions are used without explicit annotations, eliminating false errors in mutually recursive code:
+  ```gleam
+  type Test(a) {
+    Test(a)
+  }
+
+  fn it(value: Test(a)) {
+    it2(value)
+  }
+  
+  fn it2(value: Test(a)) -> Test(a) {
+    it(value)
+  }
+  ```
+  Previously this could fail with an incorrect "Type mismatch" error:
+  ```
+  Type mismatch
+
+  The type of this returned value doesn't match the return type
+  annotation of this function.
+
+  Expected type:
+
+    Test(a)
+
+  Found type:
+
+    Test(a)
+  ```
+  ([Adi Salimgereyev](https://github.com/abs0luty))
+
 ### Build tool
 
 - The help text displayed by `gleam dev --help`, `gleam test --help`, and

compiler-core/src/analyse.rs

@@ -673,8 +673,18 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
         }
 
         // Assert that the inferred type matches the type of any recursive call
-        if let Err(error) = unify(preregistered_type.clone(), type_) {
-            self.problems.error(convert_unify_error(error, location));
+        if let Err(error) = unify(preregistered_type.clone(), type_.clone()) {
+            let mut instantiated_ids = im::HashMap::new();
+            let flexible_hydrator = Hydrator::new();
+            let instantiated_annotation = environment.instantiate(
+                preregistered_type.clone(),
+                &mut instantiated_ids,
+                &flexible_hydrator,
+            );
+
+            if unify(instantiated_annotation, type_.clone()).is_err() {
+                self.problems.error(convert_unify_error(error, location));
+            }
         }
 
         // Ensure that the current target has an implementation for the function.
@@ -715,10 +725,13 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             purity,
         };
 
+        // Store the inferred type (not the preregistered type) in the environment.
+        // This ensures concrete type information flows through recursive calls - e.g., if we infer
+        // `fn() -> Test(Int)`, callers see that instead of the generic `fn() -> Test(a)`.
         environment.insert_variable(
             name.clone(),
             variant,
-            preregistered_type.clone(),
+            type_.clone(),
             publicity,
             deprecation.clone(),
         );
@@ -731,6 +744,8 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             ReferenceKind::Definition,
         );
 
+        // Use the inferred return type for the typed AST node.
+        // This matches the type stored in the environment above.
         let function = Function {
             documentation: doc,
             location,
@@ -741,7 +756,7 @@ impl<'a, A> ModuleAnalyzer<'a, A> {
             body_start,
             end_position: end_location,
             return_annotation,
-            return_type: preregistered_type
+            return_type: type_
                 .return_type()
                 .expect("Could not find return type for fn"),
             body,

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__action__type_variables_in_let_bindings_are_considered_when_adding_annotations.snap

@@ -15,7 +15,7 @@ fn wibble(a, b, c) {
 
 ----- AFTER ACTION
 
-fn wibble(a: e, b: f, c: g) -> fn(b, c) -> d {
+fn wibble(a: e, b: f, c: g) -> fn(b, c) -> h {
   let x: a = todo
   fn(a: b, b: c) -> d {
     todo

compiler-core/src/type_/expression.rs

@@ -4707,31 +4707,39 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
             if let Ok(body) = Vec1::try_from_vec(body) {
                 let mut body = body_typer.infer_statements(body);
 
-                // Check that any return type is accurate.
-                if let Some(return_type) = return_type
-                    && let Err(error) = unify(return_type, body.last().type_())
-                {
-                    let error = error
-                        .return_annotation_mismatch()
-                        .into_error(body.last().type_defining_location());
-                    body_typer.problems.error(error);
-
-                    // If the return type doesn't match with the annotation we
-                    // add a new expression to the end of the function to match
-                    // the annotated type and allow type inference to keep
-                    // going.
-                    body.push(Statement::Expression(TypedExpr::Invalid {
-                        // This is deliberately an empty span since this
-                        // placeholder expression is implicitly inserted by the
-                        // compiler and doesn't actually appear in the source
-                        // code.
-                        location: SrcSpan {
-                            start: body.last().location().end,
-                            end: body.last().location().end,
-                        },
-                        type_: body_typer.new_unbound_var(),
-                        extra_information: None,
-                    }))
+                // Check that any return type is compatible with the annotation.
+                if let Some(return_type) = return_type {
+                    let mut instantiated_ids = hashmap![];
+                    let flexible_hydrator = Hydrator::new();
+                    let instantiated_annotation = body_typer.environment.instantiate(
+                        return_type.clone(),
+                        &mut instantiated_ids,
+                        &flexible_hydrator,
+                    );
+
+                    if let Err(error) = unify(instantiated_annotation, body.last().type_()) {
+                        let error = error
+                            .return_annotation_mismatch()
+                            .into_error(body.last().type_defining_location());
+                        body_typer.problems.error(error);
+
+                        // If the return type doesn't match with the annotation we
+                        // add a new expression to the end of the function to match
+                        // the annotated type and allow type inference to keep
+                        // going.
+                        body.push(Statement::Expression(TypedExpr::Invalid {
+                            // This is deliberately an empty span since this
+                            // placeholder expression is implicitly inserted by the
+                            // compiler and doesn't actually appear in the source
+                            // code.
+                            location: SrcSpan {
+                                start: body.last().location().end,
+                                end: body.last().location().end,
+                            },
+                            type_: body_typer.new_unbound_var(),
+                            extra_information: None,
+                        }))
+                    }
                 };
 
                 Ok((arguments, body.to_vec()))

compiler-core/src/type_/tests/functions.rs

@@ -169,6 +169,56 @@ pub fn two(x) {
     );
 }
 
+// https://github.com/gleam-lang/gleam/issues/2550
+#[test]
+fn mutual_recursion_keeps_generic_return_annotation() {
+    assert_module_infer!(
+        r#"
+pub type Test(a) {
+  Test(a)
+}
+
+pub fn it(value: Test(a)) {
+  it2(value)
+}
+
+pub fn it2(value: Test(a)) -> Test(a) {
+  it(value)
+}
+
+pub fn main() {
+  it(Test(1))
+}
+"#,
+        vec![
+            (r#"Test"#, r#"fn(a) -> Test(a)"#),
+            (r#"it"#, r#"fn(Test(a)) -> Test(a)"#),
+            (r#"it2"#, r#"fn(Test(a)) -> Test(a)"#),
+            (r#"main"#, r#"fn() -> Test(Int)"#)
+        ]
+    );
+}
+
+// https://github.com/gleam-lang/gleam/issues/2533
+#[test]
+fn unbound_type_variable_in_top_level_definition() {
+    assert_module_infer!(
+        r#"
+pub type Foo(a) {
+  Foo(value: Int)
+}
+
+pub fn main() {
+  Foo(1)
+}
+"#,
+        vec![
+            (r#"Foo"#, r#"fn(Int) -> Foo(a)"#),
+            (r#"main"#, r#"fn() -> Foo(a)"#),
+        ]
+    );
+}
+
 #[test]
 fn no_impl_function_fault_tolerance() {
     // A function not having an implementation does not stop analysis.