fix: resolve builder StackOverflow, activator negative refCount, binding regression, and testing extensions (#4301)

## What's Changed

### Builder converter registration no longer causes StackOverflow
Calling `WithFallbackConverter`, `WithConverter`,
`WithSetMethodConverter`, or `WithConvertersFrom` on
`IReactiveUIBuilder` previously caused a `StackOverflowException` due to
infinite recursion. These methods now work correctly.

### ViewModelActivator no longer goes into a broken state on extra
Deactivate calls
If `Deactivate()` was called more times than `Activate()`, the internal
reference count would go negative, preventing future activations from
working. The activator now safely ignores extra deactivation calls.

### Two-way bindings work again with base types like System.Object
Two-way bindings between a view model property of a derived type (e.g.
`string`) and a view property of a base type (e.g. `object`) were
throwing `ArgumentException`. This is now permitted as expected.

### TestScheduler extensions (AdvanceByMs, AdvanceToMs, etc.) are
discoverable again
After adding the `ReactiveUI.Testing.Reactive` package, `AdvanceByMs`,
`AdvanceToMs`, `OnNextAt`, and related extensions are now available with
just `using ReactiveUI.Testing;` -- no additional namespace import
needed.

Fixes #4293
Fixes #4283
Fixes #4298
Fixes #4297

---

## Maintainer Notes

- **IReactiveUIBuilder.cs**: Added 9 converter method signatures
(`WithConverter` x4, `WithFallbackConverter` x2,
`WithSetMethodConverter` x2, `WithConvertersFrom` x1) to the interface.
These were previously only on the concrete `ReactiveUIBuilder` class,
causing the extension methods in `BuilderMixins.cs` to resolve back to
themselves instead of dispatching to the implementation.
- **ViewModelActivator.cs**: Replaced `Interlocked.Decrement` in
`Deactivate()` with a CAS (CompareExchange) loop that refuses to
decrement below zero. The `ignoreRefCount` path now explicitly resets to
0.
- **PropertyBinderImplementation.cs**: Changed the type assignability
check from `&&` (mutual) to `||` (one-directional). The existing
fallback conversion logic at lines 180-184 already handles
one-directional assignment.
- **TestSchedulerExtensions.cs**: Changed namespace from
`ReactiveUI.Testing.Reactive` to `ReactiveUI.Testing`. The
assembly/package name remains `ReactiveUI.Testing.Reactive` -- the move
to a separate package is intentional to keep `ReactiveUI.Testing` free
of the `Microsoft.Reactive.Testing` dependency.
- **Test updates**: Added new interface members to
`TestReactiveUIBuilder` mock in Blazor tests, removed now-unnecessary
`using ReactiveUI.Testing.Reactive` from scheduler tests.

Author: glennawatson

dotnet-install.sh

@@ -7,6 +7,7 @@
     <PackageDescription>Provides TestScheduler extensions for testing ReactiveUI applications with Microsoft.Reactive.Testing</PackageDescription>
     <PackageId>ReactiveUI.Testing.Reactive</PackageId>
     <PackageTags>mvvm;reactiveui;rx;reactive extensions;observable;LINQ;events;frp;test;testscheduler;</PackageTags>
+    <IsPackable>true</IsPackable>
   </PropertyGroup>
   <ItemGroup>
     <Using Include="System" />

src/ReactiveUI.Testing.Reactive/ReactiveUI.Testing.Reactive.csproj

@@ -6,7 +6,7 @@
 using System.Reactive;
 using Microsoft.Reactive.Testing;
 
-namespace ReactiveUI.Testing.Reactive;
+namespace ReactiveUI.Testing;
 
 /// <summary>
 /// Extension methods for TestScheduler from Microsoft.Reactive.Testing.

src/ReactiveUI.Testing.Reactive/TestSchedulerExtensions.cs

@@ -90,7 +90,30 @@ public IDisposable Activate()
     /// </param>
     public void Deactivate(bool ignoreRefCount = false)
     {
-        if (Interlocked.Decrement(ref _refCount) == 0 || ignoreRefCount)
+        if (ignoreRefCount)
+        {
+            Interlocked.Exchange(ref _refCount, 0);
+            Interlocked.Exchange(ref _activationHandle, Disposable.Empty).Dispose();
+            _deactivated.OnNext(Unit.Default);
+            return;
+        }
+
+        // Guard against going negative — only decrement if current value is > 0
+        int current;
+        int next;
+        do
+        {
+            current = Volatile.Read(ref _refCount);
+            if (current <= 0)
+            {
+                return;
+            }
+
+            next = current - 1;
+        }
+        while (Interlocked.CompareExchange(ref _refCount, next, current) != current);
+
+        if (next == 0)
         {
             Interlocked.Exchange(ref _activationHandle, Disposable.Empty).Dispose();
             _deactivated.OnNext(Unit.Default);

src/ReactiveUI/Activation/ViewModelActivator.cs

@@ -100,7 +100,7 @@ internal PropertyBinderImplementation(
 
         // Check if we have converters or if types are assignable
         var hasConverters = vmToViewConverterObj is not null && viewToVMConverterObj is not null;
-        var typesAreAssignable = typeof(TVProp).IsAssignableFrom(typeof(TVMProp)) && typeof(TVMProp).IsAssignableFrom(typeof(TVProp));
+        var typesAreAssignable = typeof(TVProp).IsAssignableFrom(typeof(TVMProp)) || typeof(TVMProp).IsAssignableFrom(typeof(TVProp));
 
         if (!hasConverters && !typesAreAssignable)
         {

src/ReactiveUI/Bindings/Property/PropertyBinderImplementation.cs

@@ -219,6 +219,73 @@ IReactiveUIBuilder WithPlatformModule<T>()
     /// <returns>The builder instance for chaining.</returns>
     IReactiveUIBuilder WithCacheSizes(int smallCacheLimit, int bigCacheLimit);
 
+    /// <summary>
+    /// Registers a typed binding converter using the concrete type.
+    /// </summary>
+    /// <typeparam name="TFrom">The source type for the conversion.</typeparam>
+    /// <typeparam name="TTo">The target type for the conversion.</typeparam>
+    /// <param name="converter">The converter instance to register.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithConverter<TFrom, TTo>(BindingTypeConverter<TFrom, TTo> converter);
+
+    /// <summary>
+    /// Registers a typed binding converter using the interface.
+    /// </summary>
+    /// <param name="converter">The converter instance to register.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithConverter(IBindingTypeConverter converter);
+
+    /// <summary>
+    /// Registers a typed binding converter via factory (lazy instantiation).
+    /// </summary>
+    /// <typeparam name="TFrom">The source type for the conversion.</typeparam>
+    /// <typeparam name="TTo">The target type for the conversion.</typeparam>
+    /// <param name="factory">The factory function that creates the converter.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithConverter<TFrom, TTo>(Func<BindingTypeConverter<TFrom, TTo>> factory);
+
+    /// <summary>
+    /// Registers a typed binding converter via factory (interface, lazy instantiation).
+    /// </summary>
+    /// <param name="factory">The factory function that creates the converter.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithConverter(Func<IBindingTypeConverter> factory);
+
+    /// <summary>
+    /// Registers a fallback binding converter.
+    /// </summary>
+    /// <param name="converter">The fallback converter instance to register.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithFallbackConverter(IBindingFallbackConverter converter);
+
+    /// <summary>
+    /// Registers a fallback binding converter via factory (lazy instantiation).
+    /// </summary>
+    /// <param name="factory">The factory function that creates the fallback converter.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithFallbackConverter(Func<IBindingFallbackConverter> factory);
+
+    /// <summary>
+    /// Registers a set-method binding converter.
+    /// </summary>
+    /// <param name="converter">The set-method converter instance to register.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithSetMethodConverter(ISetMethodBindingConverter converter);
+
+    /// <summary>
+    /// Registers a set-method binding converter via factory (lazy instantiation).
+    /// </summary>
+    /// <param name="factory">The factory function that creates the set-method converter.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithSetMethodConverter(Func<ISetMethodBindingConverter> factory);
+
+    /// <summary>
+    /// Imports all converters from a Splat dependency resolver into the builder.
+    /// </summary>
+    /// <param name="resolver">The Splat resolver to import converters from.</param>
+    /// <returns>The builder instance for chaining.</returns>
+    IReactiveUIBuilder WithConvertersFrom(IReadonlyDependencyResolver resolver);
+
     /// <summary>
     /// Withes the views from assembly.
     /// </summary>

src/ReactiveUI/Builder/IReactiveUIBuilder.cs

@@ -259,5 +259,23 @@ public IReactiveUIBuilder UsingSplatModule<T>(T registrationModule)
         public IReactiveUIBuilder WithSuspensionHost<TAppState>() => throw new NotImplementedException();
 
         public IReactiveUIBuilder WithCacheSizes(int smallCacheLimit, int bigCacheLimit) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithConverter<TFrom, TTo>(BindingTypeConverter<TFrom, TTo> converter) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithConverter(IBindingTypeConverter converter) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithConverter<TFrom, TTo>(Func<BindingTypeConverter<TFrom, TTo>> factory) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithConverter(Func<IBindingTypeConverter> factory) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithFallbackConverter(IBindingFallbackConverter converter) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithFallbackConverter(Func<IBindingFallbackConverter> factory) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithSetMethodConverter(ISetMethodBindingConverter converter) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithSetMethodConverter(Func<ISetMethodBindingConverter> factory) => throw new NotImplementedException();
+
+        public IReactiveUIBuilder WithConvertersFrom(IReadonlyDependencyResolver resolver) => throw new NotImplementedException();
     }
 }

src/tests/ReactiveUI.Blazor.Tests/BlazorReactiveUIBuilderExtensionsTests.cs

@@ -125,6 +125,65 @@ public async Task WithConvertersFrom_ReturnsBuilderForChaining()
         await Assert.That(result).IsSameReferenceAs(builder);
     }
 
+    [Test]
+    public async Task WithFallbackConverter_Instance_ReturnsBuilderForChaining()
+    {
+        using var locator = new ModernDependencyResolver();
+        var builder = locator.CreateReactiveUIBuilder();
+        var converter = new TestFallbackConverter();
+
+        var result = builder.WithFallbackConverter(converter);
+
+        await Assert.That(result).IsSameReferenceAs(builder);
+    }
+
+    [Test]
+    public void WithFallbackConverter_Instance_WithNull_Throws()
+    {
+        using var locator = new ModernDependencyResolver();
+        var builder = locator.CreateReactiveUIBuilder();
+
+        Assert.Throws<ArgumentNullException>(() =>
+            builder.WithFallbackConverter((IBindingFallbackConverter)null!));
+    }
+
+    [Test]
+    public async Task WithFallbackConverter_Factory_ReturnsBuilderForChaining()
+    {
+        using var locator = new ModernDependencyResolver();
+        var builder = locator.CreateReactiveUIBuilder();
+
+        var result = builder.WithFallbackConverter(() => new TestFallbackConverter());
+
+        await Assert.That(result).IsSameReferenceAs(builder);
+    }
+
+    [Test]
+    public void WithFallbackConverter_Factory_WithNull_Throws()
+    {
+        using var locator = new ModernDependencyResolver();
+        var builder = locator.CreateReactiveUIBuilder();
+
+        Assert.Throws<ArgumentNullException>(() =>
+            builder.WithFallbackConverter((Func<IBindingFallbackConverter>)null!));
+    }
+
+    [Test]
+    public async Task WithFallbackConverter_ViaInterfaceTypedVariable_DoesNotRecurse()
+    {
+        // Regression test for https://github.com/reactiveui/ReactiveUI/issues/4293
+        // Calling WithFallbackConverter on an IReactiveUIBuilder-typed variable caused
+        // infinite recursion (StackOverflowException) because the extension method in
+        // BuilderMixins called itself instead of delegating to the interface method.
+        using var locator = new ModernDependencyResolver();
+        IReactiveUIBuilder builder = locator.CreateReactiveUIBuilder();
+        var converter = new TestFallbackConverter();
+
+        var result = builder.WithFallbackConverter(converter);
+
+        await Assert.That(result).IsSameReferenceAs(builder);
+    }
+
     private sealed class TestTypedConverter : BindingTypeConverter<int, string>
     {
         public override int GetAffinityForObjects() => 1;
@@ -150,4 +209,15 @@ public bool TryConvertTyped(object? from, object? conversionHint, out object? re
             return from != null;
         }
     }
+
+    private sealed class TestFallbackConverter : IBindingFallbackConverter
+    {
+        public int GetAffinityForObjects(Type fromType, Type toType) => 1;
+
+        public bool TryConvert(Type fromType, object from, Type toType, object? conversionHint, [NotNullWhen(true)] out object? result)
+        {
+            result = from;
+            return true;
+        }
+    }
 }

src/tests/ReactiveUI.Builder.Tests/ReactiveUIBuilderConverterTests.cs

@@ -7,8 +7,6 @@
 
 using Microsoft.Reactive.Testing;
 
-using ReactiveUI.Testing.Reactive;
-
 using TUnit.Core.Executors;
 
 namespace ReactiveUI.Testing.Tests;

src/tests/ReactiveUI.Testing.Tests/SchedulerExtensionTests.cs

@@ -2040,7 +2040,14 @@ namespace ReactiveUI.Builder
         ReactiveUI.Builder.IReactiveUIBuilder UsingSplatModule<T>(T registrationModule)
             where T : Splat.Builder.IModule;
         ReactiveUI.Builder.IReactiveUIBuilder WithCacheSizes(int smallCacheLimit, int bigCacheLimit);
+        ReactiveUI.Builder.IReactiveUIBuilder WithConverter(ReactiveUI.IBindingTypeConverter converter);
+        ReactiveUI.Builder.IReactiveUIBuilder WithConverter(System.Func<ReactiveUI.IBindingTypeConverter> factory);
+        ReactiveUI.Builder.IReactiveUIBuilder WithConverter<TFrom, TTo>(ReactiveUI.BindingTypeConverter<TFrom, TTo> converter);
+        ReactiveUI.Builder.IReactiveUIBuilder WithConverter<TFrom, TTo>(System.Func<ReactiveUI.BindingTypeConverter<TFrom, TTo>> factory);
+        ReactiveUI.Builder.IReactiveUIBuilder WithConvertersFrom(Splat.IReadonlyDependencyResolver resolver);
         ReactiveUI.Builder.IReactiveUIBuilder WithExceptionHandler(System.IObserver<System.Exception> exceptionHandler);
+        ReactiveUI.Builder.IReactiveUIBuilder WithFallbackConverter(ReactiveUI.IBindingFallbackConverter converter);
+        ReactiveUI.Builder.IReactiveUIBuilder WithFallbackConverter(System.Func<ReactiveUI.IBindingFallbackConverter> factory);
         ReactiveUI.Builder.IReactiveUIInstance WithInstance<T>(System.Action<T?> action);
         ReactiveUI.Builder.IReactiveUIInstance WithInstance<T1, T2>(System.Action<T1?, T2?> action);
         ReactiveUI.Builder.IReactiveUIInstance WithInstance<T1, T2, T3>(System.Action<T1?, T2?, T3?> action);
@@ -2066,6 +2073,8 @@ namespace ReactiveUI.Builder
         ReactiveUI.Builder.IReactiveUIBuilder WithPlatformServices();
         ReactiveUI.Builder.IReactiveUIBuilder WithRegistration(System.Action<Splat.IMutableDependencyResolver> configureAction);
         ReactiveUI.Builder.IReactiveUIBuilder WithRegistrationOnBuild(System.Action<Splat.IMutableDependencyResolver> configureAction);
+        ReactiveUI.Builder.IReactiveUIBuilder WithSetMethodConverter(ReactiveUI.ISetMethodBindingConverter converter);
+        ReactiveUI.Builder.IReactiveUIBuilder WithSetMethodConverter(System.Func<ReactiveUI.ISetMethodBindingConverter> factory);
         ReactiveUI.Builder.IReactiveUIBuilder WithSuspensionHost();
         ReactiveUI.Builder.IReactiveUIBuilder WithSuspensionHost<TAppState>();
         ReactiveUI.Builder.IReactiveUIBuilder WithTaskPoolScheduler(System.Reactive.Concurrency.IScheduler scheduler, bool setRxApp = true);