Struct TracerSubtypeChecker 

pub struct TracerSubtypeChecker<'a> { /* private fields */ }

Tracer-based subtype checker.

This provides a unified API for both fast boolean checks and detailed diagnostics by using the SubtypeTracer trait to abstract the failure handling.

The checker maintains its own cycle detection and depth tracking to avoid interfering with the main SubtypeChecker state.

Implementations

impl<'a> TracerSubtypeChecker<'a>

pub fn new(interner: &'a dyn TypeDatabase) -> Self

Create a new tracer-based subtype checker.

pub const fn with_strict_function_types(self, strict: bool) -> Self

Set whether to use strict function types.

pub const fn with_allow_void_return(self, allow: bool) -> Self

Set whether to allow void return type optimization.

pub const fn with_strict_null_checks(self, strict: bool) -> Self

Set strict null checks mode.

pub fn check_subtype_with_tracer<T: SubtypeTracer>( &mut self, source: TypeId, target: TypeId, tracer: &mut T, ) -> bool

Check if a type is a subtype of another, using the provided tracer.

This is the main entry point for tracer-based subtype checking. The tracer determines whether we collect detailed diagnostics or just return a boolean.

Parameters

• source: The source type (the “from” type in source <: target)
• target: The target type (the “to” type in source <: target)
• tracer: The tracer to use for failure handling

Returns

• true if source is a subtype of target
• false otherwise

Example

// Fast check
let mut fast = FastTracer;
let ok = checker.check_subtype_with_tracer(source, target, &mut fast);

// With diagnostics
let mut diag = DiagnosticTracer::new();
checker.check_subtype_with_tracer(source, target, &mut diag);
if let Some(reason) = diag.take_failure() {
    eprintln!("Type error: {:?}", reason);
}