Merge worker-8

Author: mohsen1

wasm/src/solver/compat.rs

@@ -22,6 +22,8 @@ pub struct CompatChecker<'a, R: TypeResolver = NoopResolver> {
     strict_null_checks: bool,
     no_unchecked_indexed_access: bool,
     exact_optional_property_types: bool,
+    /// When true, enables additional strict subtype checking rules for lib.d.ts
+    strict_subtype_checking: bool,
     cache: FxHashMap<(TypeId, TypeId), bool>,
 }
 
@@ -36,6 +38,7 @@ impl<'a> CompatChecker<'a, NoopResolver> {
             strict_null_checks: true,
             no_unchecked_indexed_access: false,
             exact_optional_property_types: false,
+            strict_subtype_checking: false,
             cache: FxHashMap::default(),
         }
     }
@@ -52,6 +55,7 @@ impl<'a, R: TypeResolver> CompatChecker<'a, R> {
             strict_null_checks: true,
             no_unchecked_indexed_access: false,
             exact_optional_property_types: false,
+            strict_subtype_checking: false,
             cache: FxHashMap::default(),
         }
     }
@@ -91,6 +95,18 @@ impl<'a, R: TypeResolver> CompatChecker<'a, R> {
     }
 
     /// Configure strict mode for `any` propagation.
+
+    /// Configure strict subtype checking mode for lib.d.ts type checking.
+    ///
+    /// When enabled, applies additional strictness rules that reject borderline
+    /// cases allowed by TypeScript's legacy behavior. This includes disabling
+    /// method bivariance for soundness.
+    pub fn set_strict_subtype_checking(&mut self, strict: bool) {
+        if self.strict_subtype_checking != strict {
+            self.strict_subtype_checking = strict;
+            self.cache.clear();
+        }
+    }
     ///
     /// When strict mode is enabled, `any` does NOT silence structural mismatches.
     /// This means the type checker will still report errors even when `any` is involved,
@@ -235,6 +251,8 @@ impl<'a, R: TypeResolver> CompatChecker<'a, R> {
         self.subtype.exact_optional_property_types = self.exact_optional_property_types;
         self.subtype.strict_null_checks = self.strict_null_checks;
         self.subtype.no_unchecked_indexed_access = self.no_unchecked_indexed_access;
+        // In strict mode, disable method bivariance for soundness
+        self.subtype.disable_method_bivariance = self.strict_subtype_checking;
     }
 
     fn violates_weak_type(&self, source: TypeId, target: TypeId) -> bool {

wasm/src/solver/subtype.rs

@@ -174,6 +174,9 @@ pub struct SubtypeChecker<'a, R: TypeResolver = NoopResolver> {
     pub no_unchecked_indexed_access: bool,
     /// Whether to enforce weak type detection (optional-only targets require overlap).
     pub enforce_weak_types: bool,
+    // When true, disables method bivariance (methods use contravariance).
+    // Default: false (methods are bivariant in TypeScript for compatibility).
+    pub disable_method_bivariance: bool,
 }
 
 impl<'a> SubtypeChecker<'a, NoopResolver> {
@@ -193,6 +196,7 @@ impl<'a> SubtypeChecker<'a, NoopResolver> {
             strict_null_checks: true,
             no_unchecked_indexed_access: false,
             enforce_weak_types: true, // Enable to catch weak type violations (TS2559)
+            disable_method_bivariance: false,
         }
     }
 }
@@ -213,6 +217,7 @@ impl<'a, R: TypeResolver> SubtypeChecker<'a, R> {
             strict_null_checks: true,
             no_unchecked_indexed_access: false,
             enforce_weak_types: true, // Enable to catch weak type violations (TS2559)
+            disable_method_bivariance: false,
         }
     }