Typecheck let bindings using annotated type

Author: abs0luty

compiler-core/src/type_/expression.rs

@@ -1973,47 +1973,51 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
             compiled_case: _,
         } = assignment;
         let value = self.expr_in_new_scope(|this| this.infer(value));
-        let type_ = value.type_();
+        let value_type = value.type_();
         let kind = self.infer_assignment_kind(kind.clone());
 
-        // Ensure the pattern matches the type of the value
-        let mut pattern_typer = pattern::PatternTyper::new(
-            self.environment,
-            &self.implementations,
-            &self.current_function_definition,
-            &self.hydrator,
-            self.problems,
-            PatternPosition::LetAssignment,
-        );
+        let mut annotation_type_override = None;
 
-        let pattern = pattern_typer.infer_single_pattern(pattern, &value);
-
-        let minimum_required_version = pattern_typer.minimum_required_version;
-        if minimum_required_version > self.minimum_required_version {
-            self.minimum_required_version = minimum_required_version;
-        }
-
-        let pattern_typechecked_successfully = !pattern_typer.error_encountered;
-
-        // Check that any type annotation is accurate.
         if let Some(annotation) = &annotation {
             match self
                 .type_from_ast(annotation)
                 .map(|type_| self.instantiate(type_, &mut hashmap![]))
             {
                 Ok(annotated_type) => {
-                    if let Err(error) = unify(annotated_type, type_.clone())
+                    let annotation_type_for_pattern = annotated_type.clone();
+                    if let Err(error) = unify(annotated_type, value_type.clone())
                         .map_err(|e| convert_unify_error(e, value.type_defining_location()))
                     {
                         self.problems.error(error);
                     }
+                    annotation_type_override = Some(annotation_type_for_pattern);
                 }
                 Err(error) => {
                     self.problems.error(error);
                 }
             }
         }
 
+        // Ensure the pattern matches the type of the value
+        let mut pattern_typer = pattern::PatternTyper::new(
+            self.environment,
+            &self.implementations,
+            &self.current_function_definition,
+            &self.hydrator,
+            self.problems,
+            PatternPosition::LetAssignment,
+        );
+
+        let pattern =
+            pattern_typer.infer_single_pattern(pattern, &value, annotation_type_override.clone());
+
+        let minimum_required_version = pattern_typer.minimum_required_version;
+        if minimum_required_version > self.minimum_required_version {
+            self.minimum_required_version = minimum_required_version;
+        }
+
+        let pattern_typechecked_successfully = !pattern_typer.error_encountered;
+
         // The exhaustiveness checker expects patterns to be valid and to type check;
         // if they are invalid, it will crash. Therefore, if any errors were found
         // when type checking the pattern, we don't perform the exhaustiveness check.
@@ -2029,7 +2033,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         }
 
         let (output, not_exhaustive_error) =
-            self.check_let_exhaustiveness(location, value.type_(), &pattern);
+            self.check_let_exhaustiveness(location, value_type.clone(), &pattern);
 
         match (&kind, not_exhaustive_error) {
             // The pattern is exhaustive in a let assignment, there's no problem here.

compiler-core/src/type_/pattern.rs

@@ -330,10 +330,13 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
         &mut self,
         pattern: UntypedPattern,
         subject: &TypedExpr,
+        subject_type_override: Option<Arc<Type>>,
     ) -> TypedPattern {
         let subject_variable = Self::subject_variable(subject);
 
-        let typed_pattern = self.unify(pattern, subject.type_(), subject_variable);
+        let subject_type = subject_type_override.unwrap_or_else(|| subject.type_());
+
+        let typed_pattern = self.unify(pattern, subject_type, subject_variable);
         self.register_variables();
         typed_pattern
     }

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

@@ -743,6 +743,19 @@ fn module_could_not_unify6() {
     assert_module_error!("fn main() { let x: String = 5 x }");
 }
 
+#[test]
+fn module_could_not_unify_let_binding_annotation_follow_up() {
+    assert_module_error!(
+        "
+pub fn main() {
+  let x: String = 5
+  let y: Int = x
+  let z: String = x
+}
+"
+    );
+}
+
 #[test]
 fn module_could_not_unify7() {
     assert_module_error!("fn main() { let assert 5 = \"\" }");

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__module_could_not_unify_let_binding_annotation_follow_up.snap

@@ -0,0 +1,43 @@
+---
+source: compiler-core/src/type_/tests/errors.rs
+assertion_line: 748
+expression: "\npub fn main() {\n  let x: String = 5\n  let y: Int = x\n  let z: String = x\n}\n"
+snapshot_kind: text
+---
+----- SOURCE CODE
+
+pub fn main() {
+  let x: String = 5
+  let y: Int = x
+  let z: String = x
+}
+
+
+----- ERROR
+error: Type mismatch
+  ┌─ /src/one/two.gleam:3:19
+  │
+3 │   let x: String = 5
+  │                   ^
+
+Expected type:
+
+    String
+
+Found type:
+
+    Int
+
+error: Type mismatch
+  ┌─ /src/one/two.gleam:4:16
+  │
+4 │   let y: Int = x
+  │                ^
+
+Expected type:
+
+    Int
+
+Found type:
+
+    String