Typecheck let bindings using annotated type

Author: abs0luty

CHANGELOG.md

@@ -16,6 +16,10 @@
   and prevents publishing packages with empty modules to Hex.
   ([Vitor Souza](https://github.com/vit0rr))
 
+- Let bindings now continue to assume their annotated type after mismatches,
+  preventing misleading follow-up errors.
+  ([Adi Salimgereyev](https://github.com/abs0luty))
+
 ### Build tool
 
 - The help text displayed by `gleam dev --help`, `gleam test --help`, and

compiler-core/src/type_/expression.rs

@@ -1976,44 +1976,48 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
         let 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) => {
+                    let annotation_type_for_pattern = annotated_type.clone();
                     if let Err(error) = unify(annotated_type, 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, 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_unify9.snap

@@ -6,6 +6,34 @@ expression: "fn main() { let assert [1, 2, ..x]: List(String) = [1,2,3] x }"
 fn main() { let assert [1, 2, ..x]: List(String) = [1,2,3] x }
 
 ----- ERROR
+error: Type mismatch
+  ┌─ /src/one/two.gleam:1:25
+  │
+1 │ fn main() { let assert [1, 2, ..x]: List(String) = [1,2,3] x }
+  │                         ^
+
+Expected type:
+
+    String
+
+Found type:
+
+    Int
+
+error: Type mismatch
+  ┌─ /src/one/two.gleam:1:28
+  │
+1 │ fn main() { let assert [1, 2, ..x]: List(String) = [1,2,3] x }
+  │                            ^
+
+Expected type:
+
+    String
+
+Found type:
+
+    Int
+
 error: Type mismatch
   ┌─ /src/one/two.gleam:1:52
   │

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

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

@@ -39,19 +39,3 @@ Expected type:
 Found type:
 
     Int
-
-error: Type mismatch
-  ┌─ /src/one/two.gleam:5:11
-  │
-5 │   let c = a + 2
-  │           ^
-
-The + operator expects arguments of this type:
-
-    Int
-
-But this argument has this type:
-
-    String
-
-Hint: Strings can be joined using the `<>` operator.

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

@@ -32,3 +32,17 @@ Expected type:
 Found type:
 
     Box(Int)
+
+error: Type mismatch
+  ┌─ /src/one/two.gleam:4:3
+  │
+4 │   x + y + z
+  │   ^
+
+The + operator expects arguments of this type:
+
+    Int
+
+But this argument has this type:
+
+    Bool