Release v1.1.2 (#48)

- Update to use variable list for `ForExpression`
* Allow `UsingExpression` to pass a variable
* update nugets

---------

Co-authored-by: bfarmer67 <bfarmer67@users.noreply.github.com>
Co-authored-by: Brenton Farmer <brent.farmer@wagglebee.net>
Co-authored-by: MattEdwardsWaggleBee <MattEdwardsWaggleBee@users.noreply.github.com>

Author: MattEdwardsWaggleBee

Directory.Build.props

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <MajorVersion>1</MajorVersion>
     <MinorVersion>1</MinorVersion>
-    <PatchVersion>1</PatchVersion>
+    <PatchVersion>2</PatchVersion>
   </PropertyGroup>
   <!-- Disable automatic package publishing -->
   <PropertyGroup>

src/Hyperbee.Expressions/ForExpression.cs

@@ -1,5 +1,4 @@
-using System.Collections.ObjectModel;
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 
 namespace Hyperbee.Expressions;
 

src/Hyperbee.Expressions/StringFormatExpression.cs

@@ -1,5 +1,4 @@
-
-using System.Linq.Expressions;
+using System.Linq.Expressions;
 using System.Reflection;
 
 namespace Hyperbee.Expressions;

src/Hyperbee.Expressions/UsingExpression.cs

@@ -4,14 +4,16 @@ namespace Hyperbee.Expressions;
 
 public class UsingExpression : Expression
 {
+    public ParameterExpression DisposeVariable { get; }
     public Expression Disposable { get; }
     public Expression Body { get; }
 
-    internal UsingExpression( Expression disposable, Expression body )
+    internal UsingExpression( ParameterExpression variable, Expression disposable, Expression body )
     {
         if ( !typeof( IDisposable ).IsAssignableFrom( disposable.Type ) )
             throw new ArgumentException( $"The disposable expression must return an {nameof( IDisposable )}.", nameof( disposable ) );
 
+        DisposeVariable = variable;
         Disposable = disposable;
         Body = body;
     }
@@ -23,38 +25,44 @@ internal UsingExpression( Expression disposable, Expression body )
 
     public override Expression Reduce()
     {
-        var disposableVar = Variable( Disposable.Type, "disposable" );
-        var disposableAssignment = Assign( disposableVar, Disposable );
+        var disposableAssignment = Assign( DisposeVariable, Disposable );
 
         var finallyBlock = IfThen(
-            NotEqual( disposableVar, Constant( null ) ),
-            Call( disposableVar, nameof( IDisposable.Dispose ), Type.EmptyTypes )
+            NotEqual( DisposeVariable, Constant( null ) ),
+            Call( DisposeVariable, nameof( IDisposable.Dispose ), Type.EmptyTypes )
         );
 
         return Block(
-            [disposableVar],
+            [DisposeVariable],
             disposableAssignment,
             TryFinally( Body, finallyBlock )
         );
     }
 
     protected override Expression VisitChildren( ExpressionVisitor visitor )
     {
+        var newDisposeVariable = visitor.VisitAndConvert( DisposeVariable, nameof( VisitChildren ) );
         var newDisposable = visitor.Visit( Disposable );
         var newBody = visitor.Visit( Body );
 
-        if ( newDisposable == Disposable && newBody == Body )
+        if ( newDisposeVariable == DisposeVariable && newDisposable == Disposable && newBody == Body )
             return this;
 
-        return new UsingExpression( newDisposable, newBody );
+        return new UsingExpression( newDisposeVariable, newDisposable, newBody );
 
     }
 }
 
 public static partial class ExpressionExtensions
 {
+    public static UsingExpression Using( ParameterExpression variable, Expression disposable, Expression body )
+    {
+        return new UsingExpression( variable, disposable, body );
+    }
+
     public static UsingExpression Using( Expression disposable, Expression body )
     {
-        return new UsingExpression( disposable, body );
+        var disposableVar = Expression.Variable( disposable.Type, "disposable" );
+        return new UsingExpression( disposableVar, disposable, body );
     }
 }

test/Hyperbee.Expressions.Benchmark/Hyperbee.Expressions.Benchmark.csproj

@@ -10,7 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
-    <PackageReference Include="DotNext.Metaprogramming" Version="5.17.2" />
+    <PackageReference Include="DotNext.Metaprogramming" Version="5.18.0" />
     <PackageReference Include="FastExpressionCompiler" Version="5.0.1" />
   </ItemGroup>
 

test/Hyperbee.Expressions.Tests/Hyperbee.Expressions.Tests.csproj

@@ -13,14 +13,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="coverlet.collector" Version="6.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="FastExpressionCompiler" Version="5.0.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="3.7.0" />
-    <PackageReference Include="MSTest.TestFramework" Version="3.7.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.7.3" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.7.3" />
   </ItemGroup>
 
   <ItemGroup>

test/Hyperbee.Expressions.Tests/UsingExpressionTests.cs

@@ -35,19 +35,21 @@ public void UsingExpression_ShouldDisposeResource_AfterUse()
     {
         // Arrange
         var resource = new TestDisposableResource();
+        var disposableVariable = Variable( typeof( TestDisposableResource ) );
         var disposableExpression = Constant( resource, typeof( TestDisposableResource ) );
 
-        var bodyExpression = Empty(); // Actual body is unimportant
+        var bodyExpression = Condition( Property( disposableVariable, nameof( TestDisposableResource.IsDisposed ) ), Constant( true ), Constant( false ) );
 
         // Act
-        var usingExpression = Using( disposableExpression, bodyExpression );
+        var usingExpression = Using( disposableVariable, disposableExpression, bodyExpression );
 
-        var lambda = Lambda<Action>( usingExpression );
+        var lambda = Lambda<Func<bool>>( usingExpression );
         var compiledLambda = lambda.Compile();
 
-        compiledLambda();
+        var result = compiledLambda();
 
         // Assert
+        Assert.IsFalse( result );
         Assert.IsTrue( resource.IsDisposed, "Resource should be disposed after using the expression." );
     }