Add even more observability

Author: purefunctor

Cargo.lock

@@ -16,9 +16,11 @@ indexmap = "2.12.1"
 interner = { version = "0.1.0", path = "../interner" }
 itertools = "0.14.0"
 lowering = { version = "0.1.0", path = "../lowering" }
+parsing = { version = "0.1.0", path = "../parsing" }
 petgraph = "0.8.3"
 pretty = "0.12"
 resolving = { version = "0.1.0", path = "../resolving" }
 rustc-hash = "2.1.1"
 smol_str = "0.3.4"
+stabilizing = { version = "0.1.0", path = "../stabilizing" }
 sugar = { version = "0.1.0", path = "../sugar" }

compiler-core/checking/Cargo.toml

@@ -15,6 +15,7 @@ use lowering::{
 };
 use resolving::ResolvedModule;
 use rustc_hash::FxHashMap;
+use stabilizing::StabilizedModule;
 use sugar::{Bracketed, Sectioned};
 
 use crate::algorithm::{constraint, transfer};
@@ -343,6 +344,7 @@ where
     pub known_generic: Option<KnownGeneric>,
 
     pub id: FileId,
+    pub stabilized: Arc<StabilizedModule>,
     pub indexed: Arc<IndexedModule>,
     pub lowered: Arc<LoweredModule>,
     pub grouped: Arc<GroupedModule>,
@@ -363,6 +365,7 @@ where
         state: &mut CheckState,
         id: FileId,
     ) -> QueryResult<CheckContext<'a, Q>> {
+        let stabilized = queries.stabilized(id)?;
         let indexed = queries.indexed(id)?;
         let lowered = queries.lowered(id)?;
         let grouped = queries.grouped(id)?;
@@ -399,6 +402,7 @@ where
             known_reflectable,
             known_generic,
             id,
+            stabilized,
             indexed,
             lowered,
             grouped,

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

@@ -39,6 +39,8 @@ where
     Q: ExternalQueries,
 {
     state.with_error_step(ErrorStep::TermDeclaration(item_id), |state| {
+        let _span = tracing::debug_span!("check_term_signature").entered();
+
         let Some(item) = context.lowered.info.get_term_item(item_id) else {
             return Ok(());
         };
@@ -57,6 +59,8 @@ where
                     .map(|(quantified_type, _)| quantified_type)
                     .unwrap_or(inferred_type);
 
+                crate::debug_fields!(state, context, { quantified_type = quantified_type });
+
                 let global_type = transfer::globalize(state, context, quantified_type);
                 state.checked.terms.insert(item_id, global_type);
             }
@@ -106,10 +110,14 @@ where
 {
     let CheckInstance { item_id, constraints, arguments, resolution } = input;
     state.with_error_step(ErrorStep::TermDeclaration(item_id), |state| {
+        let _span = tracing::debug_span!("check_instance").entered();
+
         let Some((class_file, class_item)) = *resolution else {
             return Ok(());
         };
 
+        crate::debug_fields!(state, context, { ?class_file = class_file, ?class_item = class_item });
+
         let TermItemKind::Instance { id: instance_id } = context.indexed.items[item_id].kind else {
             return Ok(());
         };
@@ -252,6 +260,7 @@ where
 {
     let CheckValueGroup { item_id, signature, equations } = input;
     state.with_error_step(ErrorStep::TermDeclaration(item_id), |state| {
+        let _span = tracing::debug_span!("check_value_group").entered();
         if let Some(signature_id) = signature {
             let group_type = term::lookup_file_term(state, context, context.id, item_id)?;
 
@@ -262,10 +271,12 @@ where
                 inspect::inspect_signature_core(state, context, group_type, surface_bindings)?;
 
             term::check_equations(state, context, *signature_id, signature, equations)?;
+            crate::debug_fields!(state, context, { group_type = group_type }, "checking");
             Ok(None)
         } else {
             let (inferred_type, residual_constraints) =
                 term::infer_equations(state, context, item_id, equations)?;
+            crate::debug_fields!(state, context, { inferred_type = inferred_type }, "inferring");
             Ok(Some(InferredValueGroup { inferred_type, residual_constraints }))
         }
     })
@@ -290,6 +301,7 @@ where
     };
 
     state.with_error_step(ErrorStep::TermDeclaration(item_id), |state| {
+        let _span = tracing::debug_span!("commit_value_group").entered();
         for constraint in result.ambiguous {
             let constraint = transfer::globalize(state, context, constraint);
             state.insert_error(ErrorKind::AmbiguousConstraint { constraint });
@@ -298,6 +310,7 @@ where
             let constraint = transfer::globalize(state, context, constraint);
             state.insert_error(ErrorKind::NoInstanceFound { constraint });
         }
+        crate::debug_fields!(state, context, { quantified = result.quantified });
     });
 
     let type_id = transfer::globalize(state, context, result.quantified);
@@ -435,6 +448,8 @@ where
     } = input;
 
     state.with_error_step(ErrorStep::TermDeclaration(instance_id), |state| {
+        let _span = tracing::debug_span!("check_instance_member_group").entered();
+
         // Save the current size of the environment for unbinding.
         let size = state.type_scope.size();
 

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

@@ -73,6 +73,8 @@ where
     Q: ExternalQueries,
 {
     state.with_error_step(ErrorStep::TypeDeclaration(item_id), |state| {
+        let _span = tracing::debug_span!("check_type_item").entered();
+
         let Some(item) = context.lowered.info.get_type_item(item_id) else {
             return Ok(None);
         };
@@ -168,6 +170,8 @@ where
         state.type_scope.unbind(level);
     }
 
+    crate::debug_fields!(state, context, { inferred_kind = inferred_kind });
+
     Ok(Some(CheckedTypeItem::Data(CheckedData {
         inferred_kind,
         kind_variables,
@@ -216,6 +220,8 @@ where
         state.type_scope.unbind(variable.level);
     }
 
+    crate::debug_fields!(state, context, { synonym_type = synonym_type });
+
     Ok(Some(CheckedTypeItem::Synonym(CheckedSynonym {
         inferred_kind,
         kind_variables,
@@ -287,6 +293,8 @@ where
         state.type_scope.unbind(variable.level);
     }
 
+    crate::debug_fields!(state, context, { ?superclass_count = superclasses.len(), ?member_count = members.len() });
+
     Ok(Some(CheckedTypeItem::Class(CheckedClass {
         inferred_kind,
         kind_variables,
@@ -630,6 +638,8 @@ where
     Q: ExternalQueries,
 {
     state.with_error_step(ErrorStep::TypeDeclaration(item_id), |state| {
+        let _span = tracing::debug_span!("check_type_signature").entered();
+
         let Some(item) = context.lowered.info.get_type_item(item_id) else {
             return Ok(());
         };
@@ -831,6 +841,7 @@ fn check_constructor_arguments<Q>(
 where
     Q: ExternalQueries,
 {
+    let _span = tracing::debug_span!("check_constructor_arguments").entered();
     let mut constructors = vec![];
 
     for item_id in context.indexed.pairs.data_constructors(item_id) {
@@ -840,24 +851,33 @@ where
             continue;
         };
 
-        let mut inferred_arguments = vec![];
-
-        for &argument in arguments.iter() {
-            let inferred_type =
-                state.with_error_step(ErrorStep::ConstructorArgument(argument), |state| {
-                    let (inferred_type, _) =
-                        kind::check_surface_kind(state, context, argument, context.prim.t)?;
-                    Ok(inferred_type)
-                })?;
-            inferred_arguments.push(inferred_type);
-        }
+        let arguments = arguments
+            .iter()
+            .map(|argument| infer_constructor_argument(state, context, *argument))
+            .try_collect()?;
 
-        constructors.push(CheckedConstructor { item_id, arguments: inferred_arguments });
+        constructors.push(CheckedConstructor { item_id, arguments });
     }
 
     Ok(constructors)
 }
 
+fn infer_constructor_argument<Q>(
+    state: &mut CheckState,
+    context: &CheckContext<Q>,
+    argument: lowering::TypeId,
+) -> Result<interner::Id<Type>, building_types::QueryError>
+where
+    Q: ExternalQueries,
+{
+    state.with_error_step(ErrorStep::ConstructorArgument(argument), |state| {
+        let _span = tracing::debug_span!("infer_constructor_argument").entered();
+        let (inferred_type, _) =
+            kind::check_surface_kind(state, context, argument, context.prim.t)?;
+        Ok(inferred_type)
+    })
+}
+
 /// Infers roles for type parameters based on their usage in constructors.
 fn infer_roles(
     state: &mut CheckState,

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

@@ -13,11 +13,14 @@ use indexing::{DeriveId, IndexedModule, InstanceId, TermItemId, TypeItemId};
 use lowering::{GroupedModule, LoweredModule};
 use resolving::ResolvedModule;
 use rustc_hash::FxHashMap;
+use stabilizing::StabilizedModule;
 
 use crate::error::CheckError;
 
 pub trait ExternalQueries:
     QueryProxy<
+        Parsed = parsing::FullParsedModule,
+        Stabilized = Arc<StabilizedModule>,
         Indexed = Arc<IndexedModule>,
         Lowered = Arc<LoweredModule>,
         Grouped = Arc<GroupedModule>,
@@ -76,6 +79,7 @@ impl CheckedModule {
 }
 
 pub fn check_module(queries: &impl ExternalQueries, file_id: FileId) -> QueryResult<CheckedModule> {
+    let _span = trace::check_module(queries, file_id)?;
     let prim_id = queries.prim_id();
     if file_id == prim_id {
         algorithm::check_prim(queries, prim_id)