Release 5.0.2

CHANGELOG.md

@@ -1,6 +1,28 @@
 Release Notes
 ====
 
+# 02-17-2024
+<a href="https://www.nuget.org/packages/dotnext/5.0.2">DotNext 5.0.2</a>
+* Fixed XML docs
+
+<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.0.2">DotNext.Metaprogramming 5.0.2</a>
+* Fixed [223](https://github.com/dotnet/dotNext/issues/223)
+
+<a href="https://www.nuget.org/packages/dotnext.unsafe/5.0.2">DotNext.Unsafe 5.0.2</a>
+* Updated dependencies
+
+<a href="https://www.nuget.org/packages/dotnext.threading/5.0.2">DotNext.Threading 5.0.2</a>
+* Added correct validation for maximum possible timeout for all `WaitAsync` methods
+
+<a href="https://www.nuget.org/packages/dotnext.io/5.0.2">DotNext.IO 5.0.2</a>
+* Updated dependencies
+
+<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.0.2">DotNext.Net.Cluster 5.0.2</a>
+* Prevent indexing of WAL files on Windows
+
+<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.0.2">DotNext.AspNetCore.Cluster 5.0.2</a>
+* Updated dependencies
+
 # 01-23-2024
 <a href="https://www.nuget.org/packages/dotnext/5.0.1">DotNext 5.0.1</a>
 * Smallish performance improvements of dynamic buffers

README.md

@@ -44,30 +44,27 @@ All these things are implemented in 100% managed code on top of existing .NET AP
 * [NuGet Packages](https://www.nuget.org/profiles/rvsakno)
 
 # What's new
-Release Date: 01-23-2024
+Release Date: 02-17-2024
 
-<a href="https://www.nuget.org/packages/dotnext/5.0.1">DotNext 5.0.1</a>
-* Smallish performance improvements of dynamic buffers
+<a href="https://www.nuget.org/packages/dotnext/5.0.2">DotNext 5.0.2</a>
+* Fixed XML docs
 
-<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.0.1">DotNext.Metaprogramming 5.0.1</a>
-* Updated dependencies
+<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.0.2">DotNext.Metaprogramming 5.0.2</a>
+* Fixed [223](https://github.com/dotnet/dotNext/issues/223)
 
-<a href="https://www.nuget.org/packages/dotnext.unsafe/5.0.1">DotNext.Unsafe 5.0.1</a>
+<a href="https://www.nuget.org/packages/dotnext.unsafe/5.0.2">DotNext.Unsafe 5.0.2</a>
 * Updated dependencies
 
-<a href="https://www.nuget.org/packages/dotnext.threading/5.0.1">DotNext.Threading 5.0.1</a>
-* Updated dependencies
+<a href="https://www.nuget.org/packages/dotnext.threading/5.0.2">DotNext.Threading 5.0.2</a>
+* Added correct validation for maximum possible timeout for all `WaitAsync` methods
 
-<a href="https://www.nuget.org/packages/dotnext.io/5.0.1">DotNext.IO 5.0.1</a>
-* Improved performance of `FileWriter` and `FileBufferingWriter` classes by utilizing Scatter/Gather IO
-* Reduced memory allocations required by async methods of `FileWriter` and `FileBufferingWriter` classes
+<a href="https://www.nuget.org/packages/dotnext.io/5.0.2">DotNext.IO 5.0.2</a>
 * Updated dependencies
 
-<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.0.1">DotNext.Net.Cluster 5.0.1</a>
-* Improved IO performance of Persistent WAL due to related improvements in DotNext.IO library
-* Updated dependencies
+<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.0.2">DotNext.Net.Cluster 5.0.2</a>
+* Prevent indexing of WAL files on Windows
 
-<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.0.1">DotNext.AspNetCore.Cluster 5.0.1</a>
+<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.0.2">DotNext.AspNetCore.Cluster 5.0.2</a>
 * Updated dependencies
 
 Changelog for previous versions located [here](./CHANGELOG.md).

src/Directory.Packages.props

@@ -19,22 +19,22 @@
   </ItemGroup>
   <ItemGroup>
     <!--Microsoft packages-->
-    <PackageVersion Include="Microsoft.AspNetCore.Connections.Abstractions" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.AspNetCore.Connections.Abstractions" Version="8.0.2" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Http" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
     <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
   </ItemGroup>
   <ItemGroup>
     <!--Misc packages-->
     <PackageVersion Include="BenchmarkDotNet" Version="0.13.12" />
     <PackageVersion Include="FastMember.Signed" Version="1.5.0" />
-    <PackageVersion Include="xunit" Version="2.6.5" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.6"/>
+    <PackageVersion Include="xunit" Version="2.7.0" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.7"/>
     <PackageVersion Include="coverlet.collector" Version="6.0.0"/>
   </ItemGroup>
 </Project>

src/DotNext.IO/DotNext.IO.csproj

@@ -11,7 +11,7 @@
     <Authors>.NET Foundation and Contributors</Authors>
     <Company />
     <Product>.NEXT Family of Libraries</Product>
-    <VersionPrefix>5.0.1</VersionPrefix>
+    <VersionPrefix>5.0.2</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <AssemblyName>DotNext.IO</AssemblyName>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/DotNext.Metaprogramming/DotNext.Metaprogramming.csproj

@@ -8,7 +8,7 @@
     <ImplicitUsings>true</ImplicitUsings>
     <IsTrimmable>false</IsTrimmable>
     <Features>nullablePublicOnly</Features>
-    <VersionPrefix>5.0.1</VersionPrefix>
+    <VersionPrefix>5.0.2</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <Authors>.NET Foundation</Authors>
     <Product>.NEXT Family of Libraries</Product>

src/DotNext.Metaprogramming/Linq/Expressions/AsyncResultExpression.cs

@@ -60,6 +60,10 @@ public AsyncResultExpression(bool valueTask)
     /// </remarks>
     public override Type Type => taskType;
 
+    // indicates that AsyncResult cannot throw exception so it can be inlined
+    internal bool IsSimpleResult
+        => AsyncResult is ConstantExpression or ParameterExpression or DefaultExpression;
+
     /// <summary>
     /// Translates this expression into predefined set of expressions
     /// using Lowering technique.
@@ -103,4 +107,7 @@ protected override AsyncResultExpression VisitChildren(ExpressionVisitor visitor
         var expression = visitor.Visit(AsyncResult);
         return ReferenceEquals(expression, AsyncResult) ? this : new(expression, taskType);
     }
+
+    internal AsyncResultExpression Update(Expression asyncResult)
+        => new(asyncResult, taskType);
 }

src/DotNext.Metaprogramming/Linq/Expressions/CollectionAccessExpression.cs

@@ -138,11 +138,11 @@ public override Expression Reduce()
         if (indexer is null)
             result = ArrayAccess(temp ?? Collection, Index);
         else if (count is null)
-            result = MakeIndex(temp ?? Collection, indexer, new[] { Index.Reduce() });
+            result = MakeIndex(temp ?? Collection, indexer, [Index.Reduce()]);
         else
-            result = MakeIndex(temp ?? Collection, indexer, new[] { MakeIndex(temp ?? Collection, count, Index) });
+            result = MakeIndex(temp ?? Collection, indexer, [MakeIndex(temp ?? Collection, count, Index)]);
 
-        return temp is null ? result : Block(Type, new[] { temp }, Assign(temp, Collection), result);
+        return temp is null ? result : Block(Type, [temp], Assign(temp, Collection), result);
     }
 
     /// <summary>

src/DotNext.Metaprogramming/Linq/Expressions/ExpressionBuilder.cs

@@ -1206,7 +1206,7 @@ internal static Expression AddEpilogue(this Expression expression, bool inferTyp
     [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(Activator))]
     public static MethodCallExpression New(this Expression type, params Expression[] args)
     {
-        var activate = typeof(Activator).GetMethod(nameof(Activator.CreateInstance), new[] { typeof(Type), typeof(object[]) });
+        var activate = typeof(Activator).GetMethod(nameof(Activator.CreateInstance), [typeof(Type), typeof(object[])]);
         Debug.Assert(activate is not null);
         return Expression.Call(activate, type, Expression.NewArrayInit(typeof(object), args));
     }
@@ -1456,9 +1456,9 @@ public static Expression AsOptional(this Expression expression)
     public static Expression AsResult(this Expression expression)
     {
         var exception = Expression.Parameter(typeof(Exception));
-        var ctor = typeof(Result<>).MakeGenericType(expression.Type).GetConstructor(new[] { expression.Type });
+        var ctor = typeof(Result<>).MakeGenericType(expression.Type).GetConstructor([expression.Type]);
         Debug.Assert(ctor?.DeclaringType is not null);
-        var fallbackCtor = ctor.DeclaringType.GetConstructor(new[] { typeof(Exception) });
+        var fallbackCtor = ctor.DeclaringType.GetConstructor([typeof(Exception)]);
         Debug.Assert(fallbackCtor is not null);
         return Expression.TryCatch(
             Expression.New(ctor, expression),

src/DotNext.Metaprogramming/Linq/Expressions/InterpolationExpression.cs

@@ -105,19 +105,19 @@ private Expression MakePlainString()
             case 0:
                 return Constant(Format);
             case 1:
-                var formatMethod = typeof(string).GetMethod(nameof(string.Format), new[] { typeof(IFormatProvider), typeof(string), typeof(object) });
+                var formatMethod = typeof(string).GetMethod(nameof(string.Format), [typeof(IFormatProvider), typeof(string), typeof(object)]);
                 Debug.Assert(formatMethod is not null);
                 return Call(formatMethod, FormatProvider, Constant(Format), arguments[0]);
             case 2:
-                formatMethod = typeof(string).GetMethod(nameof(string.Format), new[] { typeof(IFormatProvider), typeof(string), typeof(object), typeof(object) });
+                formatMethod = typeof(string).GetMethod(nameof(string.Format), [typeof(IFormatProvider), typeof(string), typeof(object), typeof(object)]);
                 Debug.Assert(formatMethod is not null);
                 return Call(formatMethod, FormatProvider, Constant(Format), FormatProvider, arguments[0], arguments[1]);
             case 3:
-                formatMethod = typeof(string).GetMethod(nameof(string.Format), new[] { typeof(IFormatProvider), typeof(string), typeof(object), typeof(object), typeof(object) });
+                formatMethod = typeof(string).GetMethod(nameof(string.Format), [typeof(IFormatProvider), typeof(string), typeof(object), typeof(object), typeof(object)]);
                 Debug.Assert(formatMethod is not null);
                 return Call(formatMethod, FormatProvider, Constant(Format), FormatProvider, arguments[0], arguments[1], arguments[2]);
             default:
-                formatMethod = typeof(string).GetMethod(nameof(string.Format), new[] { typeof(IFormatProvider), typeof(string), typeof(object[]) });
+                formatMethod = typeof(string).GetMethod(nameof(string.Format), [typeof(IFormatProvider), typeof(string), typeof(object[])]);
                 Debug.Assert(formatMethod is not null);
                 return Call(formatMethod, FormatProvider, Constant(Format), FormatProvider, NewArrayInit(typeof(object), arguments));
         }

src/DotNext.Metaprogramming/Linq/Expressions/ItemIndexExpression.cs

@@ -74,7 +74,7 @@ internal static Expression GetOffset(Expression index, Expression count)
     /// <returns>Translated expression.</returns>
     public override Expression Reduce()
     {
-        ConstructorInfo? ctor = typeof(Index).GetConstructor(new[] { typeof(int), typeof(bool) });
+        ConstructorInfo? ctor = typeof(Index).GetConstructor([typeof(int), typeof(bool)]);
         Debug.Assert(ctor is not null);
         return New(ctor, conversionRequired ? Convert(Value, typeof(int)) : Value, Constant(IsFromEnd));
     }

src/DotNext.Metaprogramming/Linq/Expressions/LockExpression.cs

@@ -94,9 +94,9 @@ public Expression Body
     [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(Monitor))]
     public override Expression Reduce()
     {
-        var monitorEnter = typeof(Monitor).GetMethod(nameof(Monitor.Enter), new[] { typeof(object) });
+        var monitorEnter = typeof(Monitor).GetMethod(nameof(Monitor.Enter), [typeof(object)]);
         Debug.Assert(monitorEnter is not null);
-        var monitorExit = typeof(Monitor).GetMethod(nameof(Monitor.Exit), new[] { typeof(object) });
+        var monitorExit = typeof(Monitor).GetMethod(nameof(Monitor.Exit), [typeof(object)]);
         Debug.Assert(monitorExit is not null);
         var body = TryFinally(Body, Call(monitorExit, SyncRoot));
         return assignment is null ?

src/DotNext.Metaprogramming/Linq/Expressions/MetaExpression.cs

@@ -70,7 +70,7 @@ private static Expression ToExpression(DynamicMetaObject arg, out BindingRestric
             }
         }
 
-        return Expression.Call(typeof(ExpressionBuilder), nameof(ExpressionBuilder.Const), new[] { arg.Expression.Type }, arg.Expression);
+        return Expression.Call(typeof(ExpressionBuilder), nameof(ExpressionBuilder.Const), [arg.Expression.Type], arg.Expression);
     }
 
     private static IReadOnlyList<Expression> ToExpressions(DynamicMetaObject[] args, out BindingRestrictions restrictions)

src/DotNext.Metaprogramming/Linq/Expressions/MutationExpression.cs

@@ -95,13 +95,13 @@ public override Expression Reduce()
         if (Bindings.Count > 0)
         {
             var tempVar = Parameter(Type, "copy");
-            ICollection<Expression> statements = new List<Expression>(Bindings.Count + 2) { Assign(tempVar, result) };
+            List<Expression> statements = new(Bindings.Count + 2) { Assign(tempVar, result) };
 
             foreach (var binding in Bindings)
                 statements.Add(Assign(MakeMemberAccess(tempVar, binding.Member), binding.Expression));
 
             statements.Add(tempVar);
-            result = Block(tempVar.Type, new[] { tempVar }, statements);
+            result = Block(tempVar.Type, [tempVar], statements);
         }
 
         return result;

src/DotNext.Metaprogramming/Linq/Expressions/NullCoalescingAssignmentExpression.cs

@@ -84,7 +84,7 @@ public override Expression Reduce()
 
         return Block(
             Left.Type,
-            new[] { localVar },
+            [localVar],
             Assign(localVar, Left),
             Assign(Left, Build(localVar, Right)),
             localVar);

src/DotNext.Metaprogramming/Linq/Expressions/RangeExpression.cs

@@ -56,7 +56,7 @@ internal static Expression GetOffsetAndLength(Expression range, Expression lengt
     /// <returns>Translated expression.</returns>
     public override Expression Reduce()
     {
-        ConstructorInfo? ctor = typeof(Range).GetConstructor(new[] { typeof(Index), typeof(Index) });
+        ConstructorInfo? ctor = typeof(Range).GetConstructor([typeof(Index), typeof(Index)]);
         Debug.Assert(ctor is not null);
         return New(ctor, Start.Reduce(), End.Reduce());
     }

src/DotNext.Metaprogramming/Linq/Expressions/RefAnyValExpression.cs

@@ -42,5 +42,5 @@ public RefAnyValExpression(ParameterExpression typedRef, Type referenceType)
     /// using Lowering technique.
     /// </summary>
     /// <returns>Translated expression.</returns>
-    public override Expression Reduce() => Call(typeof(Intrinsics), nameof(Intrinsics.AsRef), new[] { ReferenceType }, TypedReferenceVar);
+    public override Expression Reduce() => Call(typeof(Intrinsics), nameof(Intrinsics.AsRef), [ReferenceType], TypedReferenceVar);
 }

src/DotNext.Metaprogramming/Linq/Expressions/SliceExpression.cs

@@ -99,7 +99,7 @@ private static IEnumerable<MethodInfo> GetSliceMethods(Type collection)
     [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(RuntimeHelpers))]
     private static MethodCallExpression SubArray(Expression array, Expression range)
     {
-        MethodInfo? subArray = typeof(RuntimeHelpers).GetMethod(nameof(RuntimeHelpers.GetSubArray), 1, new[] { Type.MakeGenericMethodParameter(0).MakeArrayType(), typeof(Range) });
+        MethodInfo? subArray = typeof(RuntimeHelpers).GetMethod(nameof(RuntimeHelpers.GetSubArray), 1, [Type.MakeGenericMethodParameter(0).MakeArrayType(), typeof(Range)]);
         Debug.Assert(subArray is not null);
         subArray = subArray.MakeGenericMethod(array.Type.GetElementType()!);
         return Call(subArray, array, range.Reduce());
@@ -108,7 +108,7 @@ private static MethodCallExpression SubArray(Expression array, Expression range)
     private static BlockExpression SubCollection(Expression collection, MethodInfo slice, PropertyInfo count, Expression range)
     {
         var offsetAndLengthCall = RangeExpression.GetOffsetAndLength(range, Property(collection, count), out var offsetAndLength, out var offsetField, out var lengthField);
-        return Block(new[] { offsetAndLength }, Assign(offsetAndLength, offsetAndLengthCall), Call(collection, slice, offsetField, lengthField));
+        return Block([offsetAndLength], Assign(offsetAndLength, offsetAndLengthCall), Call(collection, slice, offsetField, lengthField));
     }
 
     /// <summary>
@@ -127,7 +127,7 @@ public override Expression Reduce()
         else
             result = SubCollection(temp ?? Collection, slice, count, Range);
 
-        return temp is null ? result : Block(Type, new[] { temp }, Assign(temp, Collection), result);
+        return temp is null ? result : Block(Type, [temp], Assign(temp, Collection), result);
     }
 
     /// <summary>

src/DotNext.Metaprogramming/Linq/Expressions/WriteLineExpression.cs

@@ -60,7 +60,7 @@ private WriteLineExpression(Expression value, Kind kind)
     [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(TextWriter))]
     private static MethodCallExpression WriteLineTo(MemberExpression stream, Expression value)
     {
-        MethodInfo? writeLineMethod = typeof(TextWriter).GetMethod(nameof(TextWriter.WriteLine), new[] { value.Type });
+        MethodInfo? writeLineMethod = typeof(TextWriter).GetMethod(nameof(TextWriter.WriteLine), [value.Type]);
 
         // WriteLine method will always be resolved here because Type.DefaultBinder
         // chooses TextWriter.WriteLine(object) if there is no exact match
@@ -91,7 +91,7 @@ private MethodCallExpression WriteLineToError()
     [DynamicDependency(DynamicallyAccessedMemberTypes.PublicMethods, typeof(System.Diagnostics.Debug))]
     private MethodCallExpression WriteLineToDebug()
     {
-        var writeLineMethod = typeof(System.Diagnostics.Debug).GetMethod(nameof(System.Diagnostics.Debug.WriteLine), new[] { typeof(object) });
+        var writeLineMethod = typeof(System.Diagnostics.Debug).GetMethod(nameof(System.Diagnostics.Debug.WriteLine), [typeof(object)]);
         System.Diagnostics.Debug.Assert(writeLineMethod is not null);
         return Call(writeLineMethod, value.Type.IsValueType ? Convert(value, typeof(object)) : value);
     }