From da8856cf6305daf03ea3da0a62a01bd3a39d243e Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 23 Jul 2024 07:25:42 -0400 Subject: [PATCH 1/2] Refactored `Promise.Merge(Settled)` APIs to use new ref field in ref structs feature. Added net8.0 build target (net7.0 is out of support). --- .../Core/Promises/Internal/MergeInternal.cs | 203 ++- Package/Core/Promises/PromiseStaticMerge.cs | 354 ++---- .../Promises/PromiseStaticMergeSettled.cs | 1094 ++++------------- ProtoPromise/ProtoPromise.csproj | 6 +- ProtoPromise/nuget/ProtoPromise.nuspec | 6 + .../nuget/targets/net8.0/ProtoPromise.targets | 23 + 6 files changed, 510 insertions(+), 1176 deletions(-) create mode 100644 ProtoPromise/nuget/targets/net8.0/ProtoPromise.targets diff --git a/Package/Core/Promises/Internal/MergeInternal.cs b/Package/Core/Promises/Internal/MergeInternal.cs index 49ad3c10..6c72f684 100644 --- a/Package/Core/Promises/Internal/MergeInternal.cs +++ b/Package/Core/Promises/Internal/MergeInternal.cs @@ -10,7 +10,8 @@ using System.Runtime.CompilerServices; using System.Threading; -#pragma warning disable IDE0074 // Use compound assignment +#pragma warning disable IDE0090 // Use 'new(...)' +#pragma warning disable IDE0251 // Make member 'readonly' namespace Proto.Promises { @@ -32,74 +33,194 @@ internal readonly unsafe struct GetResultDelegate internal delegate void GetResultDelegate(PromiseRefBase handler, int index, ref TResult result); #endif - [MethodImpl(InlineOption)] - internal static void PrepareForMerge(Promise promise, in TResult result, ref uint pendingCount, - ref PromiseRefBase.MergePromise mergePromise, GetResultDelegate getResultDelegate) + internal ref struct MergePreparer { - if (promise._ref != null) + private PromiseRefBase.MergePromise _promise; + // ref fields are only supported in .Net 7 or later. + // We can fake it by using a Span in .Net Standard 2.1 or later. + // The Span nuget package for .Net Standard 2.0 doesn't include MemoryMarshal, so we can't use it, unfortunately. + // TODO: update compilation symbol when Unity adopts .Net Core. +#if NET7_0_OR_GREATER + private ref TResult _resultRef; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + private Span _resultRef; +#endif + private readonly GetResultDelegate _getResultDelegate; + private uint _pendingCount; + + // Annoyingly, we can't return struct fields by reference, or assign struct field reference to a ref field, so we have to pass in the initial result. + [MethodImpl(InlineOption)] + internal MergePreparer(ref TResult initialResult, GetResultDelegate getResultDelegate) + { + _promise = null; +#if NET7_0_OR_GREATER + _resultRef = ref initialResult; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + _resultRef = System.Runtime.InteropServices.MemoryMarshal.CreateSpan(ref initialResult, 1); +#endif + _getResultDelegate = getResultDelegate; + _pendingCount = 0; + } + + [MethodImpl(InlineOption)] + internal ref TResult GetResultRef(ref TResult initialResultRef) +#if NET7_0_OR_GREATER + => ref _resultRef; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + => ref _resultRef[0]; +#else + => ref _promise == null ? ref initialResultRef : ref _promise._result; +#endif + + [MethodImpl(InlineOption)] + private void PreparePending(in TResult initialResult) { - checked { ++pendingCount; } - if (mergePromise == null) + checked { ++_pendingCount; } + if (_promise == null) { - mergePromise = PromiseRefBase.GetOrCreateMergePromise(result, getResultDelegate); + _promise = PromiseRefBase.GetOrCreateMergePromise(initialResult, _getResultDelegate); +#if NET7_0_OR_GREATER + _resultRef = ref _promise._result; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + _resultRef = System.Runtime.InteropServices.MemoryMarshal.CreateSpan(ref _promise._result, 1); +#endif } - mergePromise.AddWaiter(promise._ref, promise._id); } - } - [MethodImpl(InlineOption)] - internal static void PrepareForMerge(Promise promise, ref T value, in TResult result, ref uint pendingCount, int index, - ref PromiseRefBase.MergePromise mergePromise, GetResultDelegate getResultDelegate) - { - if (promise._ref == null) + [MethodImpl(InlineOption)] + internal void Prepare(Promise promise, in TResult initialResult) { - value = promise._result; + if (promise._ref != null) + { + PreparePending(initialResult); + _promise.AddWaiter(promise._ref, promise._id); + } } - else + + [MethodImpl(InlineOption)] + internal void Prepare(Promise promise, ref T value, in TResult initialResult, int index) { - checked { ++pendingCount; } - if (mergePromise == null) + if (promise._ref == null) + { + value = promise._result; + } + else { - mergePromise = PromiseRefBase.GetOrCreateMergePromise(result, getResultDelegate); + PreparePending(initialResult); + _promise.AddWaiterWithIndex(promise._ref, promise._id, index); } - mergePromise.AddWaiterWithIndex(promise._ref, promise._id, index); } - } - [MethodImpl(InlineOption)] - internal static void PrepareForMergeSettled(Promise promise, in TResult result, ref uint pendingCount, int index, - ref PromiseRefBase.MergeSettledPromise mergePromise, GetResultDelegate getResultDelegate) - { - if (promise._ref != null) + [MethodImpl(InlineOption)] + internal Promise ToPromise(in TResult initialResult) { - checked { ++pendingCount; } - if (mergePromise == null) + if (_promise == null) { - mergePromise = PromiseRefBase.GetOrCreateMergeSettledPromise(result, getResultDelegate); + return Promise.Resolved(initialResult); } - mergePromise.AddWaiterWithIndex(promise._ref, promise._id, index); + _promise.MarkReady(_pendingCount); + return new Promise(_promise, _promise.Id); } } - [MethodImpl(InlineOption)] - internal static void PrepareForMergeSettled(Promise promise, ref Promise.ResultContainer value, in TResult result, ref uint pendingCount, int index, - ref PromiseRefBase.MergeSettledPromise mergePromise, GetResultDelegate getResultDelegate) + internal ref struct MergeSettledPreparer { - if (promise._ref == null) + private PromiseRefBase.MergeSettledPromise _promise; + // ref fields are only supported in .Net 7 or later. + // We can fake it by using a Span in .Net Standard 2.1 or later. + // The Span nuget package for .Net Standard 2.0 doesn't include MemoryMarshal, so we can't use it, unfortunately. + // TODO: update compilation symbol when Unity adopts .Net Core. +#if NET7_0_OR_GREATER + private ref TResult _resultRef; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + private Span _resultRef; +#endif + private readonly GetResultDelegate _getResultDelegate; + private uint _pendingCount; + + // Annoyingly, we can't return struct fields by reference, or assign struct field reference to a ref field, so we have to pass in the initial result. + [MethodImpl(InlineOption)] + internal MergeSettledPreparer(ref TResult initialResult, GetResultDelegate getResultDelegate) { - value = promise._result; + _promise = null; +#if NET7_0_OR_GREATER + _resultRef = ref initialResult; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + _resultRef = System.Runtime.InteropServices.MemoryMarshal.CreateSpan(ref initialResult, 1); +#endif + _getResultDelegate = getResultDelegate; + _pendingCount = 0; + } + + [MethodImpl(InlineOption)] + internal ref TResult GetResultRef(ref TResult initialResultRef) +#if NET7_0_OR_GREATER + => ref _resultRef; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + => ref _resultRef[0]; +#else + => ref _promise == null ? ref initialResultRef : ref _promise._result; +#endif + + [MethodImpl(InlineOption)] + private void PreparePending(in TResult initialResult) + { + checked { ++_pendingCount; } + if (_promise == null) + { + _promise = PromiseRefBase.GetOrCreateMergeSettledPromise(initialResult, _getResultDelegate); +#if NET7_0_OR_GREATER + _resultRef = ref _promise._result; +#elif NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER || NETCOREAPP + _resultRef = System.Runtime.InteropServices.MemoryMarshal.CreateSpan(ref _promise._result, 1); +#endif + } + } + + [MethodImpl(InlineOption)] + internal void Prepare(Promise promise, in TResult initialResult, int index) + { + if (promise._ref != null) + { + PreparePending(initialResult); + _promise.AddWaiterWithIndex(promise._ref, promise._id, index); + } + } + + [MethodImpl(InlineOption)] + internal void Prepare(Promise promise, ref Promise.ResultContainer value, in TResult initialResult, int index) + { + if (promise._ref == null) + { + value = promise._result; + } + else + { + PreparePending(initialResult); + _promise.AddWaiterWithIndex(promise._ref, promise._id, index); + } } - else + + [MethodImpl(InlineOption)] + internal Promise ToPromise(in TResult initialResult) { - checked { ++pendingCount; } - if (mergePromise == null) + if (_promise == null) { - mergePromise = PromiseRefBase.GetOrCreateMergeSettledPromise(result, getResultDelegate); + return Promise.Resolved(initialResult); } - mergePromise.AddWaiterWithIndex(promise._ref, promise._id, index); + _promise.MarkReady(_pendingCount); + return new Promise(_promise, _promise.Id); } } + [MethodImpl(InlineOption)] + internal static MergePreparer CreateMergePreparer(ref TResult initialResult, GetResultDelegate getResultDelegate) + => new MergePreparer(ref initialResult, getResultDelegate); + + [MethodImpl(InlineOption)] + internal static MergeSettledPreparer CreateMergeSettledPreparer(ref TResult initialResult, GetResultDelegate getResultDelegate) + => new MergeSettledPreparer(ref initialResult, getResultDelegate); + partial class PromiseRefBase { #if !PROTO_PROMISE_DEVELOPER_MODE diff --git a/Package/Core/Promises/PromiseStaticMerge.cs b/Package/Core/Promises/PromiseStaticMerge.cs index 4fd4b2da..4bd6bc66 100644 --- a/Package/Core/Promises/PromiseStaticMerge.cs +++ b/Package/Core/Promises/PromiseStaticMerge.cs @@ -306,23 +306,10 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise2, nameof(promise2), 1); (T1, T2) value = default; - ref (T1, T2) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetTwo(); - Internal.PromiseRefBase.MergePromise<(T1, T2)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid an extra branch, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetTwo()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + return merger.ToPromise(value); } /// @@ -336,24 +323,11 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise3, nameof(promise3), 1); (T1, T2) value = default; - ref (T1, T2) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetTwo(); - Internal.PromiseRefBase.MergePromise<(T1, T2)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid an extra branch, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - Internal.PrepareForMerge(promise3, valueRef, ref pendingCount, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetTwo()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, value); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -406,25 +380,11 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise3, nameof(promise3), 1); (T1, T2, T3) value = default; - ref (T1, T2, T3) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetThree(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetThree()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + return merger.ToPromise(value); } /// @@ -439,26 +399,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise4, nameof(promise4), 1); (T1, T2, T3) value = default; - ref (T1, T2, T3) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetThree(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - Internal.PrepareForMerge(promise4, valueRef, ref pendingCount, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetThree()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, value); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -515,27 +461,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise4, nameof(promise4), 1); (T1, T2, T3, T4) value = default; - ref (T1, T2, T3, T4) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetFour(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetFour()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + return merger.ToPromise(value); } /// @@ -551,28 +482,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise5, nameof(promise5), 1); (T1, T2, T3, T4) value = default; - ref (T1, T2, T3, T4) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetFour(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - Internal.PrepareForMerge(promise5, valueRef, ref pendingCount, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetFour()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, value); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -633,29 +549,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise5, nameof(promise5), 1); (T1, T2, T3, T4, T5) value = default; - ref (T1, T2, T3, T4, T5) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetFive(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4, T5)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4, T5)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetFive()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + return merger.ToPromise(value); } /// @@ -672,30 +572,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise6, nameof(promise6), 1); (T1, T2, T3, T4, T5) value = default; - ref (T1, T2, T3, T4, T5) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetFive(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4, T5)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - Internal.PrepareForMerge(promise6, valueRef, ref pendingCount, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4, T5)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetFive()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, value); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -760,31 +644,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise6, nameof(promise6), 1); (T1, T2, T3, T4, T5, T6) value = default; - ref (T1, T2, T3, T4, T5, T6) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSix(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4, T5, T6)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4, T5, T6)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetSix()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + return merger.ToPromise(value); } /// @@ -802,32 +669,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise7, nameof(promise7), 1); (T1, T2, T3, T4, T5, T6) value = default; - ref (T1, T2, T3, T4, T5, T6) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSix(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4, T5, T6)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - Internal.PrepareForMerge(promise7, valueRef, ref pendingCount, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4, T5, T6)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetSix()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + merger.Prepare(promise7, value); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -896,33 +746,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise7, nameof(promise7), 1); (T1, T2, T3, T4, T5, T6, T7) value = default; - ref (T1, T2, T3, T4, T5, T6, T7) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSeven(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4, T5, T6, T7)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise7, ref valueRef.Item7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4, T5, T6, T7)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetSeven()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + merger.Prepare(promise7, ref merger.GetResultRef(ref value).Item7, value, 6); + return merger.ToPromise(value); } /// @@ -941,34 +773,16 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r ValidateArgument(promise8, nameof(promise8), 1); (T1, T2, T3, T4, T5, T6, T7) value = default; - ref (T1, T2, T3, T4, T5, T6, T7) valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSeven(); - Internal.PromiseRefBase.MergePromise<(T1, T2, T3, T4, T5, T6, T7)> promise = null; - - Internal.PrepareForMerge(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMerge helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMerge(promise7, ref valueRef.Item7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - Internal.PrepareForMerge(promise8, valueRef, ref pendingCount, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(T1, T2, T3, T4, T5, T6, T7)>(promise, promise.Id); + var merger = Internal.CreateMergePreparer(ref value, MergeResultFuncs.GetSeven()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + merger.Prepare(promise7, ref merger.GetResultRef(ref value).Item7, value, 6); + merger.Prepare(promise8, value); + return merger.ToPromise(value); } } } \ No newline at end of file diff --git a/Package/Core/Promises/PromiseStaticMergeSettled.cs b/Package/Core/Promises/PromiseStaticMergeSettled.cs index 7aa2685b..76bbcc38 100644 --- a/Package/Core/Promises/PromiseStaticMergeSettled.cs +++ b/Package/Core/Promises/PromiseStaticMergeSettled.cs @@ -4,8 +4,6 @@ #undef PROMISE_DEBUG #endif -#pragma warning disable IDE0074 // Use compound assignment - using System; using System.Collections.Generic; using System.Diagnostics; @@ -319,26 +317,10 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (ResultContainer, ResultContainer) value = default; - ref (ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled2(); - Internal.PromiseRefBase.MergeSettledPromise<(ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled2()); + merger.Prepare(promise1, value, 0); + merger.Prepare(promise2, value, 1); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -388,26 +370,10 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled1(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled1()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, value, 1); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -458,26 +424,10 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled0(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled0()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + return merger.ToPromise(value); } #endregion // 2Args @@ -536,28 +486,11 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (ResultContainer, ResultContainer, ResultContainer) value = default; - ref (ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled3(); - Internal.PromiseRefBase.MergeSettledPromise<(ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled3()); + merger.Prepare(promise1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -612,28 +545,11 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled2(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled2()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -688,28 +604,11 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled1(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled1()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, value, 2); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -764,28 +663,11 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled0(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled0()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + return merger.ToPromise(value); } #endregion // 3Args @@ -848,30 +730,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled4(); - Internal.PromiseRefBase.MergeSettledPromise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled4()); + merger.Prepare(promise1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -930,30 +794,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled3(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled3()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1012,30 +858,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled2(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled2()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1095,30 +923,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled1(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled1()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, value, 3); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1178,30 +988,12 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled0(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled0()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + return merger.ToPromise(value); } #endregion // 4Args @@ -1268,32 +1060,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled5(); - Internal.PromiseRefBase.MergeSettledPromise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled5()); + merger.Prepare(promise1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1356,32 +1129,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled4(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled4()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1444,32 +1198,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled3(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled3()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1533,32 +1268,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled2(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled2()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1622,32 +1338,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled1(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled1()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, value, 4); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1711,32 +1408,13 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled0(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled0()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + return merger.ToPromise(value); } #endregion // 5Args @@ -1808,34 +1486,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled6(); - Internal.PromiseRefBase.MergeSettledPromise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled6()); + merger.Prepare(promise1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1903,34 +1561,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled5(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled5()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -1998,34 +1636,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled4(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled4()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2093,34 +1711,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled3(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled3()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2188,34 +1786,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled2(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled2()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2283,34 +1861,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled1(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled1()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, value, 5); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2378,34 +1936,14 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled0(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled0()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + return merger.ToPromise(value); } #endregion // 6Args @@ -2481,36 +2019,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled7(); - Internal.PromiseRefBase.MergeSettledPromise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled7()); + merger.Prepare(promise1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2582,36 +2099,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled6(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled6()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2683,36 +2179,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled5(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled5()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2784,36 +2259,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled4(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled4()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2885,36 +2339,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled3(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled3()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, value, 4); + merger.Prepare(promise6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -2986,36 +2419,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled2(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled2()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -3087,36 +2499,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled1(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled1()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + merger.Prepare(promise7, value, 6); + return merger.ToPromise(value); } static partial class MergeResultFuncs @@ -3188,36 +2579,15 @@ private static void GetMergeResult(Internal.PromiseRefBase handler, int index, r (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) value = default; - ref (Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer) - valueRef = ref value; - uint pendingCount = 0; - var mergeResultFunc = MergeResultFuncs.GetSettled0(); - Internal.PromiseRefBase.MergeSettledPromise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)> - promise = null; - - Internal.PrepareForMergeSettled(promise1, ref valueRef.Item1, valueRef, ref pendingCount, 0, ref promise, mergeResultFunc); - // It would be nice to be able to ref-reassign inside the PrepareForMergeSettled helper to avoid extra branches, - // but unfortunately C# doesn't support ref to ref parameters (or ref fields in ref structs yet). - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise2, ref valueRef.Item2, valueRef, ref pendingCount, 1, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise3, ref valueRef.Item3, valueRef, ref pendingCount, 2, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise4, ref valueRef.Item4, valueRef, ref pendingCount, 3, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise5, ref valueRef.Item5, valueRef, ref pendingCount, 4, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise6, ref valueRef.Item6, valueRef, ref pendingCount, 5, ref promise, mergeResultFunc); - valueRef = promise == null ? ref value : ref promise._result; - Internal.PrepareForMergeSettled(promise7, ref valueRef.Item7, valueRef, ref pendingCount, 6, ref promise, mergeResultFunc); - - if (pendingCount == 0) - { - return Resolved(value); - } - promise.MarkReady(pendingCount); - return new Promise<(Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer, Promise.ResultContainer)>( - promise, promise.Id); + var merger = Internal.CreateMergeSettledPreparer(ref value, MergeResultFuncs.GetSettled0()); + merger.Prepare(promise1, ref merger.GetResultRef(ref value).Item1, value, 0); + merger.Prepare(promise2, ref merger.GetResultRef(ref value).Item2, value, 1); + merger.Prepare(promise3, ref merger.GetResultRef(ref value).Item3, value, 2); + merger.Prepare(promise4, ref merger.GetResultRef(ref value).Item4, value, 3); + merger.Prepare(promise5, ref merger.GetResultRef(ref value).Item5, value, 4); + merger.Prepare(promise6, ref merger.GetResultRef(ref value).Item6, value, 5); + merger.Prepare(promise7, ref merger.GetResultRef(ref value).Item7, value, 6); + return merger.ToPromise(value); } #endregion // 7Args diff --git a/ProtoPromise/ProtoPromise.csproj b/ProtoPromise/ProtoPromise.csproj index dac7fcf4..89388098 100644 --- a/ProtoPromise/ProtoPromise.csproj +++ b/ProtoPromise/ProtoPromise.csproj @@ -1,7 +1,7 @@  - netstandard2.0;netstandard2.1;net6.0 + netstandard2.0;netstandard2.1;net6.0;net8.0 3.1.0 false @@ -46,8 +46,8 @@ - - 9 + + 12 true $(DefineConstants);UNITY_2021_2_OR_NEWER diff --git a/ProtoPromise/nuget/ProtoPromise.nuspec b/ProtoPromise/nuget/ProtoPromise.nuspec index 76c91ab2..b7661fda 100644 --- a/ProtoPromise/nuget/ProtoPromise.nuspec +++ b/ProtoPromise/nuget/ProtoPromise.nuspec @@ -29,6 +29,9 @@ + + + readme.md @@ -45,6 +48,9 @@ + + + diff --git a/ProtoPromise/nuget/targets/net8.0/ProtoPromise.targets b/ProtoPromise/nuget/targets/net8.0/ProtoPromise.targets new file mode 100644 index 00000000..2eaa4303 --- /dev/null +++ b/ProtoPromise/nuget/targets/net8.0/ProtoPromise.targets @@ -0,0 +1,23 @@ + + + + + + + + Release + + + + + Debug + + + + + + + $(MSBuildThisFileDirectory)..\..\lib\net8.0\$(ProtoPromiseConfiguration)\ProtoPromise.dll + + + \ No newline at end of file From ebcff13452a406b5399bd41c0cb8a911f83ab3da Mon Sep 17 00:00:00 2001 From: Tim Date: Tue, 23 Jul 2024 07:51:48 -0400 Subject: [PATCH 2/2] Fixed analyzer tests. --- .../ProtoPromiseAnalyzerUnitTests.cs | 53 ++++++------------- 1 file changed, 16 insertions(+), 37 deletions(-) diff --git a/ProtoPromise.Analyzer/ProtoPromise.Analyzer.Test/ProtoPromiseAnalyzerUnitTests.cs b/ProtoPromise.Analyzer/ProtoPromise.Analyzer.Test/ProtoPromiseAnalyzerUnitTests.cs index 330469d1..6fec4dca 100644 --- a/ProtoPromise.Analyzer/ProtoPromise.Analyzer.Test/ProtoPromiseAnalyzerUnitTests.cs +++ b/ProtoPromise.Analyzer/ProtoPromise.Analyzer.Test/ProtoPromiseAnalyzerUnitTests.cs @@ -38,7 +38,7 @@ public AsyncEnumerable IterateAsync() await new CSharpAnalyzerTest() { - ReferenceAssemblies = new ReferenceAssemblies("net6.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "6.0.0"), Path.Combine("ref", "net6.0")), + ReferenceAssemblies = new ReferenceAssemblies("net8.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "8.0.0"), Path.Combine("ref", "net8.0")), TestState = { Sources = { test }, @@ -46,6 +46,18 @@ public AsyncEnumerable IterateAsync() } }.RunAsync(); } + private static Task RunTestAsync(string test, DiagnosticResult expectedResult) + => new CSharpAnalyzerTest() + { + ReferenceAssemblies = new ReferenceAssemblies("net8.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "8.0.0"), Path.Combine("ref", "net8.0")), + TestState = + { + Sources = { test }, + AdditionalReferences = { typeof(Proto.Promises.Promise).Assembly.Location }, + ExpectedDiagnostics = { expectedResult } + } + }.RunAsync(); + [TestMethod] public async Task CannotAwaitYieldInTryWithCatch() @@ -72,18 +84,7 @@ public AsyncEnumerable IterateAsync() }"; var expected = VerifyCS.Diagnostic(YieldAsyncAnalyzer.YieldAsyncTryCatchId).WithLocation(14, 21); - - var testRunner = new CSharpAnalyzerTest() - { - ReferenceAssemblies = new ReferenceAssemblies("net6.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "6.0.0"), Path.Combine("ref", "net6.0")), - TestState = - { - Sources = { test }, - AdditionalReferences = { typeof(Proto.Promises.Promise).Assembly.Location }, - ExpectedDiagnostics = { expected } - } - }; - await testRunner.RunAsync(); + await RunTestAsync(test, expected); } [TestMethod] @@ -113,18 +114,7 @@ public AsyncEnumerable IterateAsync() }"; var expected = VerifyCS.Diagnostic(YieldAsyncAnalyzer.YieldAsyncCatchId).WithLocation(17, 21); - - var testRunner = new CSharpAnalyzerTest() - { - ReferenceAssemblies = new ReferenceAssemblies("net6.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "6.0.0"), Path.Combine("ref", "net6.0")), - TestState = - { - Sources = { test }, - AdditionalReferences = { typeof(Proto.Promises.Promise).Assembly.Location }, - ExpectedDiagnostics = { expected } - } - }; - await testRunner.RunAsync(); + await RunTestAsync(test, expected); } [TestMethod] @@ -154,18 +144,7 @@ public AsyncEnumerable IterateAsync() }"; var expected = VerifyCS.Diagnostic(YieldAsyncAnalyzer.YieldAsyncFinallyId).WithLocation(17, 21); - - var testRunner = new CSharpAnalyzerTest() - { - ReferenceAssemblies = new ReferenceAssemblies("net6.0", new PackageIdentity("Microsoft.NETCore.App.Ref", "6.0.0"), Path.Combine("ref", "net6.0")), - TestState = - { - Sources = { test }, - AdditionalReferences = { typeof(Proto.Promises.Promise).Assembly.Location }, - ExpectedDiagnostics = { expected } - } - }; - await testRunner.RunAsync(); + await RunTestAsync(test, expected); } } }