Release v1.1.3 (#60)

* [Bug] Fixes issues with AsyncTaskMethodBuilder that caused the "Prefer Interpretation" mode with the system compiler to fail for async state machines.

---------

Co-authored-by: Brenton Farmer <[email protected]>
Co-authored-by: MattEdwardsWaggleBee <[email protected]>

Author: MattEdwardsWaggleBee

Directory.Build.props

@@ -3,7 +3,10 @@
   <PropertyGroup>
     <MajorVersion>1</MajorVersion>
     <MinorVersion>1</MinorVersion>
-    <PatchVersion>2</PatchVersion>
+    <PatchVersion>3</PatchVersion>
+    <RevisionVersion>0</RevisionVersion>
+    <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
+    <FileVersion>$(MajorVersion).$(MinorVersion).$(PatchVersion).$(RevisionVersion)</FileVersion>
   </PropertyGroup>
   <!-- Disable automatic package publishing -->
   <PropertyGroup>

Directory.Build.targets

@@ -15,7 +15,6 @@
 	<Target Name="SetPackageVersion" BeforeTargets="GenerateNuspec"
 	        Condition="'$(IsPackable)'=='true'">
 		<PropertyGroup>
-			<VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
 			<PackageVersion Condition="'$(VersionSuffix)'==''">$(VersionPrefix)</PackageVersion>
 			<PackageVersion Condition="'$(VersionSuffix)'!=''">$(VersionPrefix)-$(VersionSuffix)</PackageVersion>
 		</PropertyGroup>

README.md

@@ -1,7 +1,7 @@
 # Welcome to Hyperbee Expressions
 
-`Hyperbee.Expressions` is a C# library that extends the capabilities of expression trees to handle asynchronous 
-workflows and other language constructs.
+`Hyperbee.Expressions` is a library for creating c# expression trees that extend the capabilities of standard expression 
+trees to handle asynchronous workflows and other language constructs.
 
 ## Features
 
@@ -21,6 +21,14 @@ workflows and other language constructs.
     * `StringFormatExpression`: An expression that creates a string using a supplied format string and parameters.
     * `DebugExpression`: An expression that helps when debugging expression trees.
 
+* Supports Fast Expression Compiler (FEC) for improved performance.
+
+* Supports interpreted expression trees using `lambda.Compile(preferInterpretation: true)`. 
+    ```csharp
+    var lambda = Expression.Lambda<Func<int>>(Expression.Constant(1));
+    var interpetedLambda = lambda.Compile(preferInterpretation: true);
+    ```
+
 ## Examples
 
 ### Asynchronous Expressions
@@ -37,7 +45,6 @@ public class Example
     public async Task ExampleAsync()
     {
         // Create an async block that calls async methods and assigns their results
-
         var instance = Constant( this );
         var result1 = Variable( typeof(int), "result1" );
         var result2 = Variable( typeof(int), "result2" );
@@ -119,5 +126,4 @@ Special thanks to:
 ## Contributing
 
 We welcome contributions! Please see our [Contributing Guide](https://github.com/Stillpoint-Software/.github/blob/main/.github/CONTRIBUTING.md) 
-for more details.
-
+for more detai

docs/index.md

@@ -28,6 +28,12 @@ trees to handle asynchronous workflows and other language constructs.
 
 * Supports Fast Expression Compiler (FEC) for improved performance.
 
+* Supports interpreted expression trees using `lambda.Compile(preferInterpretation: true)`. 
+    ```csharp
+    var lambda = Expression.Lambda<Func<int>>(Expression.Constant(1));
+    var interpetedLambda = lambda.Compile(preferInterpretation: true);
+    ```
+
 ## Examples
 
 ### Asynchronous Expressions

src/Hyperbee.Expressions/AsyncBlockExpression.cs

@@ -1,8 +1,8 @@
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Linq.Expressions;
+using Hyperbee.Collections;
 using Hyperbee.Expressions.CompilerServices;
-using Hyperbee.Expressions.CompilerServices.Collections;
 
 namespace Hyperbee.Expressions;
 

src/Hyperbee.Expressions/CompilerServices/AsyncInterpreterTaskBuilder.cs

@@ -0,0 +1,52 @@
+using System.Runtime.CompilerServices;
+
+namespace Hyperbee.Expressions.CompilerServices;
+
+public class AsyncInterpreterTaskBuilder<TResult>
+{
+    public AsyncTaskMethodBuilder<TResult> Builder;
+
+    public Task<TResult> Task => Builder.Task;
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void SetStateMachine( IAsyncStateMachine stateMachine )
+    {
+        Builder.SetStateMachine( stateMachine );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void Start<TStateMachine>( ref TStateMachine stateMachine ) where TStateMachine : IAsyncStateMachine
+    {
+        Builder.Start( ref stateMachine );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void SetResult( TResult result )
+    {
+        Builder.SetResult( result );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void SetException( Exception exception )
+    {
+        Builder.SetException( exception );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void AwaitOnCompleted<TAwaiter, TStateMachine>(
+        ref TAwaiter awaiter,
+        ref TStateMachine stateMachine
+    ) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+    {
+        Builder.AwaitOnCompleted( ref awaiter, ref stateMachine );
+    }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(
+        ref TAwaiter awaiter,
+        ref TStateMachine stateMachine
+    ) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
+    {
+        Builder.AwaitUnsafeOnCompleted( ref awaiter, ref stateMachine );
+    }
+}