More breadcrumbs for errors

Author: purefunctor

compiler-core/checking/src/algorithm/binder.rs

@@ -5,6 +5,7 @@ use crate::ExternalQueries;
 use crate::algorithm::state::{CheckContext, CheckState};
 use crate::algorithm::{kind, operator, term, unification};
 use crate::core::{RowField, RowType, Type, TypeId};
+use crate::error::ErrorStep;
 
 #[derive(Copy, Clone, Debug)]
 enum BinderMode {
@@ -20,7 +21,9 @@ pub fn infer_binder<Q>(
 where
     Q: ExternalQueries,
 {
-    binder_core(state, context, binder_id, BinderMode::Infer)
+    state.with_error_step(ErrorStep::InferringBinder(binder_id), |state| {
+        binder_core(state, context, binder_id, BinderMode::Infer)
+    })
 }
 
 pub fn check_binder<Q>(
@@ -32,7 +35,9 @@ pub fn check_binder<Q>(
 where
     Q: ExternalQueries,
 {
-    binder_core(state, context, binder_id, BinderMode::Check { expected_type })
+    state.with_error_step(ErrorStep::CheckingBinder(binder_id), |state| {
+        binder_core(state, context, binder_id, BinderMode::Check { expected_type })
+    })
 }
 
 fn binder_core<Q>(

compiler-core/checking/src/algorithm/kind.rs

@@ -13,6 +13,7 @@ use crate::ExternalQueries;
 use crate::algorithm::state::{CheckContext, CheckState};
 use crate::algorithm::{substitute, transfer, unification};
 use crate::core::{ForallBinder, RowField, RowType, Type, TypeId, Variable};
+use crate::error::ErrorStep;
 
 const MISSING_NAME: SmolStr = SmolStr::new_static("<MissingName>");
 
@@ -21,6 +22,19 @@ pub fn infer_surface_kind<Q>(
     context: &CheckContext<Q>,
     id: lowering::TypeId,
 ) -> QueryResult<(TypeId, TypeId)>
+where
+    Q: ExternalQueries,
+{
+    state.with_error_step(ErrorStep::InferringKind(id), |state| {
+        infer_surface_kind_core(state, context, id)
+    })
+}
+
+fn infer_surface_kind_core<Q>(
+    state: &mut CheckState,
+    context: &CheckContext<Q>,
+    id: lowering::TypeId,
+) -> QueryResult<(TypeId, TypeId)>
 where
     Q: ExternalQueries,
 {
@@ -518,9 +532,11 @@ pub fn check_surface_kind<Q>(
 where
     Q: ExternalQueries,
 {
-    let (inferred_type, inferred_kind) = infer_surface_kind(state, context, id)?;
-    let _ = unification::subtype(state, context, inferred_kind, kind)?;
-    Ok((inferred_type, inferred_kind))
+    state.with_error_step(ErrorStep::CheckingKind(id), |state| {
+        let (inferred_type, inferred_kind) = infer_surface_kind_core(state, context, id)?;
+        let _ = unification::subtype(state, context, inferred_kind, kind)?;
+        Ok((inferred_type, inferred_kind))
+    })
 }
 
 pub fn check_type_variable_binding<Q>(

compiler-core/checking/src/algorithm/term.rs

@@ -7,7 +7,7 @@ use crate::ExternalQueries;
 use crate::algorithm::state::{CheckContext, CheckState};
 use crate::algorithm::{binder, inspect, kind, operator, substitute, transfer, unification};
 use crate::core::{RowField, RowType, Type, TypeId};
-use crate::error::ErrorKind;
+use crate::error::{ErrorKind, ErrorStep};
 
 pub fn infer_equations<Q>(
     state: &mut CheckState,
@@ -245,16 +245,31 @@ pub fn check_expression<Q>(
 where
     Q: ExternalQueries,
 {
-    let inferred = infer_expression(state, context, expr_id)?;
-    let _ = unification::subtype(state, context, inferred, expected)?;
-    Ok(inferred)
+    state.with_error_step(ErrorStep::CheckingExpression(expr_id), |state| {
+        let inferred = infer_expression_quiet(state, context, expr_id)?;
+        let _ = unification::subtype(state, context, inferred, expected)?;
+        Ok(inferred)
+    })
 }
 
 pub fn infer_expression<Q>(
     state: &mut CheckState,
     context: &CheckContext<Q>,
     expr_id: lowering::ExpressionId,
 ) -> QueryResult<TypeId>
+where
+    Q: ExternalQueries,
+{
+    state.with_error_step(ErrorStep::InferringExpression(expr_id), |state| {
+        infer_expression_quiet(state, context, expr_id)
+    })
+}
+
+fn infer_expression_quiet<Q>(
+    state: &mut CheckState,
+    context: &CheckContext<Q>,
+    expr_id: lowering::ExpressionId,
+) -> QueryResult<TypeId>
 where
     Q: ExternalQueries,
 {

compiler-core/checking/src/error.rs

@@ -9,6 +9,15 @@ pub enum ErrorStep {
     TermDeclaration(indexing::TermItemId),
     TypeDeclaration(indexing::TypeItemId),
     ConstructorArgument(lowering::TypeId),
+
+    InferringKind(lowering::TypeId),
+    CheckingKind(lowering::TypeId),
+
+    InferringBinder(lowering::BinderId),
+    CheckingBinder(lowering::BinderId),
+
+    InferringExpression(lowering::ExpressionId),
+    CheckingExpression(lowering::ExpressionId),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

tests-integration/fixtures/checking/080_let_recursive_errors/Main.snap

@@ -12,8 +12,8 @@ threeWayConflict :: Int -> Int
 Types
 
 Errors
-CannotUnify { Int, String } at [TermDeclaration(Idx::<TermItem>(1))]
-CannotUnify { String, Int } at [TermDeclaration(Idx::<TermItem>(1))]
-CannotUnify { ??? -> ???, ??? } at [TermDeclaration(Idx::<TermItem>(2))]
-CannotUnify { Int, String } at [TermDeclaration(Idx::<TermItem>(3))]
-CannotUnify { String, Int } at [TermDeclaration(Idx::<TermItem>(4))]
+CannotUnify { Int, String } at [TermDeclaration(Idx::<TermItem>(1)), InferringExpression(AstId<syntax::cst::Expression>(20))]
+CannotUnify { String, Int } at [TermDeclaration(Idx::<TermItem>(1)), InferringExpression(AstId<syntax::cst::Expression>(20))]
+CannotUnify { ??? -> ???, ??? } at [TermDeclaration(Idx::<TermItem>(2)), InferringExpression(AstId<syntax::cst::Expression>(61))]
+CannotUnify { Int, String } at [TermDeclaration(Idx::<TermItem>(3)), InferringExpression(AstId<syntax::cst::Expression>(82)), InferringExpression(AstId<syntax::cst::Expression>(102)), CheckingExpression(AstId<syntax::cst::Expression>(105))]
+CannotUnify { String, Int } at [TermDeclaration(Idx::<TermItem>(4)), InferringExpression(AstId<syntax::cst::Expression>(115)), InferringExpression(AstId<syntax::cst::Expression>(135)), CheckingExpression(AstId<syntax::cst::Expression>(138))]

tests-integration/tests/snapshots/checking__constrained_invalid_constraint.snap

@@ -12,6 +12,12 @@ expression: checked.errors
             TypeDeclaration(
                 Idx::<TypeItem>(1),
             ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(7),
+            ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(8),
+            ),
         ],
     },
 ]

tests-integration/tests/snapshots/checking__constrained_invalid_type.snap

@@ -12,6 +12,12 @@ expression: checked.errors
             TypeDeclaration(
                 Idx::<TypeItem>(1),
             ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(14),
+            ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(18),
+            ),
         ],
     },
 ]

tests-integration/tests/snapshots/checking__partial_synonym.snap

@@ -11,6 +11,9 @@ expression: checked.errors
             TypeDeclaration(
                 Idx::<TypeItem>(1),
             ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(9),
+            ),
         ],
     },
     CheckError {
@@ -22,6 +25,9 @@ expression: checked.errors
             TypeDeclaration(
                 Idx::<TypeItem>(1),
             ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(9),
+            ),
         ],
     },
     CheckError {

tests-integration/tests/snapshots/checking__unification_fail.snap

@@ -15,6 +15,9 @@ expression: checked.errors
             ConstructorArgument(
                 AstId<syntax::cst::Type>(9),
             ),
+            CheckingKind(
+                AstId<syntax::cst::Type>(9),
+            ),
         ],
     },
 ]