Fixes async expression compiler bugs and updates nugets (#133)

bfarmer67 · web-flow · commit 3dc923b6b52f · 2026-02-27T13:19:50.000-08:00
* Fix value-type boxing in Transition (#126), add failing test for #123, expand ExpressionRuntimeOptions - Fix #126: Add EnsureConvert helper to Transition base class that wraps value-type expressions in Convert() when assigning to reference-type variables (boxing). Applied in Transition.SetResult and FinalTransition.AddExpressions. - Add failing test for #123: IfThen with Return(label, value) in BlockAsync returns null instead of expected value. Root cause is in the lowering phase where Returns inside non-lowered conditionals are not converted to _finalResultVariable assignments. - Expand ExpressionRuntimeOptions with Optimize flag (default true) to conditionally skip StateOptimizer, and SourceHandler callback to capture the generated state machine expression for debugging. * Change SourceHandler to Action<string> with UnsafeAccessor for DebugView, add tests * fix(expressions): Ensure Return gotos inside non-lowered expressions set final result * test(expressions): Add regression test for Return labels in async TryCatch * test(compiler): Add FastExpressionCompiler compatibility test for Return gotos with assignments * Update nugets and cleanup
diff --git a/.gitignore b/.gitignore
@@ -395,4 +395,7 @@ FodyWeavers.xsd
 *.msp
 
 # JetBrains Rider
-*.sln.iml
+*.sln.iml
+
+# Claude Code
+.claude/
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -5,25 +5,25 @@
   <ItemGroup>
     <!-- Development Tools -->
     <PackageVersion Include="Nerdbank.GitVersioning" Version="3.9.50" />
-    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="10.0.102">
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="10.0.103">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageVersion>
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
     <PackageVersion Include="DotNext.Metaprogramming" Version="5.26.2" />
     <PackageVersion Include="FastExpressionCompiler" Version="5.3.0" />
-    <PackageVersion Include="coverlet.collector" Version="6.0.4">
+    <PackageVersion Include="coverlet.collector" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageVersion>
-    <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.2" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.2" />
-    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.2" />
-    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.3" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.3" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.3" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.3" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-    <PackageVersion Include="MSTest.TestAdapter" Version="4.0.2" />
-    <PackageVersion Include="MSTest.TestFramework" Version="4.0.2" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.2" />
+    <PackageVersion Include="MSTest.TestAdapter" Version="4.1.0" />
+    <PackageVersion Include="MSTest.TestFramework" Version="4.1.0" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.3" />
     <!-- Roslyn: use consistent version for all frameworks -->
     <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="5.0.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />
diff --git a/src/Hyperbee.Expressions.Lab/Hyperbee.Expressions.Lab.csproj b/src/Hyperbee.Expressions.Lab/Hyperbee.Expressions.Lab.csproj
@@ -48,7 +48,10 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     <PackageReference Include="Microsoft.Extensions.Http" />
     <ProjectReference Include="..\Hyperbee.Expressions\Hyperbee.Expressions.csproj" />
-    <PackageReference Update="Microsoft.SourceLink.GitHub" />
+    <PackageReference Update="Microsoft.SourceLink.GitHub">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
 </Project>
diff --git a/src/Hyperbee.Expressions/AsyncBlockExpression.cs b/src/Hyperbee.Expressions/AsyncBlockExpression.cs
@@ -58,7 +58,7 @@ private AsyncLoweringInfo LoweringTransformer()
     {
         try
         {
-            var visitor = new AsyncLoweringVisitor();
+            var visitor = new AsyncLoweringVisitor { Optimize = RuntimeOptions?.Optimize ?? true };
 
             return visitor.Transform(
                 Result.Type,
diff --git a/src/Hyperbee.Expressions/CompilerServices/AsyncStateMachineBuilder.cs b/src/Hyperbee.Expressions/CompilerServices/AsyncStateMachineBuilder.cs
@@ -415,6 +415,15 @@ internal static Expression Create<TResult>( AsyncLoweringTransformer loweringTra
         var stateMachineBuilder = new AsyncStateMachineBuilder<TResult>( moduleBuilder, typeName );
         var stateMachineExpression = stateMachineBuilder.CreateStateMachine( loweringTransformer, __id );
 
+        if ( options.SourceHandler != null )
+        {
+            var debugView = GetDebugView( stateMachineExpression );
+            options.SourceHandler( debugView );
+        }
+
         return stateMachineExpression; // the-best expression breakpoint ever
     }
+
+    [UnsafeAccessor( UnsafeAccessorKind.Method, Name = "get_DebugView" )]
+    private static extern string GetDebugView( Expression expression );
 }
diff --git a/src/Hyperbee.Expressions/CompilerServices/Lowering/AsyncLoweringVisitor.cs b/src/Hyperbee.Expressions/CompilerServices/Lowering/AsyncLoweringVisitor.cs
@@ -12,6 +12,8 @@ internal class AsyncLoweringVisitor : BaseLoweringVisitor<AsyncLoweringInfo>
 
     private int _awaitCount;
 
+    public bool Optimize { get; init; } = true;
+
     public override AsyncLoweringInfo Transform(
         Type resultType,
         ParameterExpression[] localVariables,
@@ -27,7 +29,8 @@ public override AsyncLoweringInfo Transform(
 
         VisitExpressions( expressions );
 
-        StateOptimizer.Optimize( States );
+        if ( Optimize )
+            StateOptimizer.Optimize( States );
 
         ThrowIfInvalid();
 
diff --git a/src/Hyperbee.Expressions/CompilerServices/Transitions/FinalTransition.cs b/src/Hyperbee.Expressions/CompilerServices/Transitions/FinalTransition.cs
@@ -24,7 +24,7 @@ public override void AddExpressions( List<Expression> expressions, StateMachineC
         if ( expressions.Count <= 1 || expressions[^1].Type == typeof( void ) )
         {
             value ??= Constant( null, typeof( IVoidResult ) );
-            expressions.Add( Assign( variable, value ) );
+            expressions.Add( Assign( variable, EnsureConvert( value, variable.Type ) ) );
             return;
         }
 
@@ -34,7 +34,7 @@ public override void AddExpressions( List<Expression> expressions, StateMachineC
 
             if ( variable.Type.IsAssignableFrom( lastExpression.Type ) )
             {
-                expressions[^1] = Assign( variable, lastExpression );
+                expressions[^1] = Assign( variable, EnsureConvert( lastExpression, variable.Type ) );
             }
         }
     }
diff --git a/src/Hyperbee.Expressions/CompilerServices/Transitions/Transition.cs b/src/Hyperbee.Expressions/CompilerServices/Transitions/Transition.cs
@@ -30,18 +30,26 @@ private static void SetResult( List<Expression> expressions, StateMachineContext
 
             if ( variable.Type.IsAssignableFrom( lastExpression.Type ) )
             {
-                expressions[^1] = Assign( variable, lastExpression );
+                expressions[^1] = Assign( variable, EnsureConvert( lastExpression, variable.Type ) );
             }
 
             return;
         }
 
         if ( value != null && variable.Type.IsAssignableFrom( value.Type ) )
         {
-            expressions.Add( Assign( variable, value ) );
+            expressions.Add( Assign( variable, EnsureConvert( value, variable.Type ) ) );
         }
     }
 
+    protected static Expression EnsureConvert( Expression expression, Type targetType )
+    {
+        if ( expression.Type != targetType && expression.Type.IsValueType )
+            return Convert( expression, targetType );
+
+        return expression;
+    }
+
     internal abstract void Optimize( HashSet<LabelTarget> references );
 
     protected static StateNode OptimizeGotos( StateNode node )
diff --git a/src/Hyperbee.Expressions/CompilerServices/VariableResolver.cs b/src/Hyperbee.Expressions/CompilerServices/VariableResolver.cs
@@ -31,6 +31,7 @@ private static class VariableName
     private const int InitialCapacity = 8;
 
     private int _variableId;
+    private ParameterExpression _finalResultVariable;
 
     private readonly StateContext _states;
 
@@ -100,7 +101,8 @@ public Expression GetExceptionVariable( int stateId )
     [MethodImpl( MethodImplOptions.AggressiveInlining )]
     public ParameterExpression GetFinalResult( Type type )
     {
-        return AddVariable( Variable( type, VariableName.FinalResult ) );
+        _finalResultVariable = AddVariable( Variable( type, VariableName.FinalResult ) );
+        return _finalResultVariable;
     }
 
     // Resolver
@@ -150,6 +152,14 @@ protected override Expression VisitGoto( GotoExpression node )
         if ( _labels.TryGetValue( node.Target, out var label ) )
             return label;
 
+        // BUG FIX: Return gotos inside non-lowered expressions (e.g. IfThen without Await) 
+        // must assign _finalResultVariable so the state machine result is set.
+        if ( _finalResultVariable != null && node.Kind == GotoExpressionKind.Return && node.Value != null )
+        {
+            var visitedValue = Visit( node.Value );
+            return node.Update( node.Target, Assign( _finalResultVariable, visitedValue ) );
+        }
+
         return base.VisitGoto( node );
     }
 
diff --git a/src/Hyperbee.Expressions/ExpressionRuntimeOptions.cs b/src/Hyperbee.Expressions/ExpressionRuntimeOptions.cs
@@ -10,4 +10,17 @@ public class ExpressionRuntimeOptions
     /// Defaults to <see cref="DefaultModuleBuilderProvider"/>
     /// </summary>
     public IModuleBuilderProvider ModuleBuilderProvider { get; init; } = DefaultModuleBuilderProvider.Instance;
+
+    /// <summary>
+    /// Gets or sets whether state machine optimizations are enabled.
+    /// When false, the goto optimizer is skipped, preserving the raw lowered state graph.
+    /// Defaults to true.
+    /// </summary>
+    public bool Optimize { get; init; } = true;
+
+    /// <summary>
+    /// Gets or sets an optional callback to receive the generated state machine source.
+    /// When set, the state machine expression debug view is passed as a string for inspection.
+    /// </summary>
+    public Action<string> SourceHandler { get; init; }
 }
diff --git a/test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj b/test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj
@@ -17,7 +17,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Update="Microsoft.SourceLink.GitHub" />
+    <PackageReference Update="Microsoft.SourceLink.GitHub">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
 </Project>
diff --git a/test/Hyperbee.Expressions.Tests/AsyncBlockExpressionRuntimeOptionsTests.cs b/test/Hyperbee.Expressions.Tests/AsyncBlockExpressionRuntimeOptionsTests.cs
@@ -181,6 +181,67 @@ public async Task BlockAsync_MultipleCalls_ShouldUseSameModuleBuilder( CompilerT
             trackingProvider.GetModuleBuilder( ModuleKind.Async ) );
     }
 
+    [TestMethod]
+    [DataRow( CompilerType.Fast )]
+    [DataRow( CompilerType.System )]
+    [DataRow( CompilerType.Interpret )]
+    public async Task BlockAsync_SourceHandler_ShouldCaptureStateMachineSource( CompilerType compiler )
+    {
+        // Arrange
+        string capturedSource = null;
+        var options = new ExpressionRuntimeOptions
+        {
+            SourceHandler = source => capturedSource = source
+        };
+
+        var block = BlockAsync(
+            new[]
+            {
+                Await( AsyncHelper.Completer(
+                    Constant( CompleterType.Immediate ),
+                    Constant( 42 )
+                ) )
+            },
+            options
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile( compiler );
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 42, result );
+        Assert.IsNotNull( capturedSource, "SourceHandler should have been called" );
+        Assert.IsTrue( capturedSource.Length > 0, "Captured source should not be empty" );
+        Assert.IsTrue( capturedSource.Contains( "__state<>" ),
+            "Captured source should contain state machine state field" );
+        Assert.IsTrue( capturedSource.Contains( "__builder<>" ),
+            "Captured source should contain state machine builder field" );
+    }
+
+    [TestMethod]
+    public async Task BlockAsync_SourceHandler_ShouldNotBeCalled_WhenNotProvided()
+    {
+        // Arrange - no SourceHandler set
+        var block = BlockAsync(
+            Await( AsyncHelper.Completer(
+                Constant( CompleterType.Immediate ),
+                Constant( 42 )
+            ) )
+        );
+
+        var lambda = Lambda<Func<Task<int>>>( block );
+        var compiledLambda = lambda.Compile( CompilerType.Fast );
+
+        // Act - should complete without error
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.AreEqual( 42, result );
+    }
+
     // Helper: Custom test provider that tracks usage
     private class CustomTestModuleBuilderProvider : IModuleBuilderProvider
     {
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncBasicTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncBasicTests.cs
@@ -1,4 +1,6 @@
-﻿using System.Linq.Expressions;
+﻿#pragma warning disable CS0649 // Field is never assigned to, and will always have its default value
+
+using System.Linq.Expressions;
 using System.Reflection;
 using Hyperbee.Expressions.Tests.TestSupport;
 using static System.Linq.Expressions.Expression;
@@ -298,7 +300,7 @@ public async Task BlockAsync_ShouldAwaitSuccessfully_WithTask( CompilerType comp
         await compiledLambda(); // Should complete without exception
 
         // Assert
-        Assert.IsTrue( true ); // If no exception, the test is successful
+        // If no exception, the test is successful
     }
 
     [TestMethod]
@@ -646,6 +648,32 @@ public async Task BlockAsync_ShouldAwaitSuccessfully_WithBlockConditional( Compl
         Assert.AreEqual( 2, result );
     }
 
+    [TestMethod]
+    [DataRow( CompilerType.Fast )]
+    [DataRow( CompilerType.System )]
+    [DataRow( CompilerType.Interpret )]
+    public async Task BlockAsync_ShouldHandleValueTypeToObjectAssignment_WithBoxing( CompilerType compiler )
+    {
+        // Arrange: assign value-type (int) to variable before await
+        // Reproduces: https://github.com/Stillpoint-Software/hyperbee.expressions/issues/126
+        var variable = Variable( typeof( int ) );
+
+        var block = BlockAsync(
+            [variable],
+            Assign( variable, Constant( 0 ) ),
+            Await( Constant( Task.FromResult( new object() ) ) )
+        );
+
+        var lambda = Lambda<Func<Task<object>>>( block );
+        var compiledLambda = lambda.Compile( compiler );
+
+        // Act
+        var result = await compiledLambda();
+
+        // Assert
+        Assert.IsNotNull( result );
+    }
+
     public class TestContext
     {
         public int Id { get; set; }
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncConditionalTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncConditionalTests.cs
@@ -29,11 +29,8 @@ public async Task AsyncBlock_ShouldAwaitSuccessfully_WithIfThenCondition( Comple
         var lambda = Lambda<Func<Task>>( block );
         var compiledLambda = lambda.Compile( compiler );
 
-        // Act
+        // Act & Assert - test passes if no exception is thrown
         await compiledLambda();
-
-        // Assert
-        Assert.IsTrue( true ); // No exception means condition and block executed successfully
     }
 
     [TestMethod]
diff --git a/test/Hyperbee.Expressions.Tests/BlockAsyncTryCatchTests.cs b/test/Hyperbee.Expressions.Tests/BlockAsyncTryCatchTests.cs
diff --git a/test/Hyperbee.Expressions.Tests/Compiler/CompilerCompatibilityTests.cs b/test/Hyperbee.Expressions.Tests/Compiler/CompilerCompatibilityTests.cs
diff --git a/test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj b/test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj
diff --git a/test/Hyperbee.Expressions.Tests/TestSupport/StateMachineCompilerHelper.cs b/test/Hyperbee.Expressions.Tests/TestSupport/StateMachineCompilerHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ private AsyncLoweringInfo LoweringTransformer()`
`58`	`58`	`{`
`59`	`59`	`try`
`60`	`60`	`{`
`61`		`- var visitor = new AsyncLoweringVisitor();`
	`61`	`+ var visitor = new AsyncLoweringVisitor { Optimize = RuntimeOptions?.Optimize ?? true };`
`62`	`62`
`63`	`63`	`return visitor.Transform(`
`64`	`64`	`Result.Type,`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public override void AddExpressions( List<Expression> expressions, StateMachineC`
`24`	`24`	`if ( expressions.Count <= 1 \|\| expressions[^1].Type == typeof( void ) )`
`25`	`25`	`{`
`26`	`26`	`value ??= Constant( null, typeof( IVoidResult ) );`
`27`		`- expressions.Add( Assign( variable, value ) );`
	`27`	`+ expressions.Add( Assign( variable, EnsureConvert( value, variable.Type ) ) );`
`28`	`28`	`return;`
`29`	`29`	`}`
`30`	`30`
`@@ -34,7 +34,7 @@ public override void AddExpressions( List<Expression> expressions, StateMachineC`
`34`	`34`
`35`	`35`	`if ( variable.Type.IsAssignableFrom( lastExpression.Type ) )`
`36`	`36`	`{`
`37`		`- expressions[^1] = Assign( variable, lastExpression );`
	`37`	`+ expressions[^1] = Assign( variable, EnsureConvert( lastExpression, variable.Type ) );`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,18 +30,26 @@ private static void SetResult( List<Expression> expressions, StateMachineContext`
`30`	`30`
`31`	`31`	`if ( variable.Type.IsAssignableFrom( lastExpression.Type ) )`
`32`	`32`	`{`
`33`		`- expressions[^1] = Assign( variable, lastExpression );`
	`33`	`+ expressions[^1] = Assign( variable, EnsureConvert( lastExpression, variable.Type ) );`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`return;`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`if ( value != null && variable.Type.IsAssignableFrom( value.Type ) )`
`40`	`40`	`{`
`41`		`- expressions.Add( Assign( variable, value ) );`
	`41`	`+ expressions.Add( Assign( variable, EnsureConvert( value, variable.Type ) ) );`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
	`45`	`+ protected static Expression EnsureConvert( Expression expression, Type targetType )`
	`46`	`+ {`
	`47`	`+ if ( expression.Type != targetType && expression.Type.IsValueType )`
	`48`	`+ return Convert( expression, targetType );`
	`49`	`+`
	`50`	`+ return expression;`
	`51`	`+ }`
	`52`	`+`
`45`	`53`	`internal abstract void Optimize( HashSet<LabelTarget> references );`
`46`	`54`
`47`	`55`	`protected static StateNode OptimizeGotos( StateNode node )`