Mirror changes from dotnet/coreclr (#29044)

dotnet-bot · ahsonkhan · commit 1b643bd08da2 · 2018-04-12T10:30:28.000-07:00
* Avoid Unsafe.As usage in ValueTask that can break type safety (#17471) Unsafe.As yields a performance improvement over using a normal cast, and it's fine when ValueTask is used correctly, but if the ValueTask instance were to be stored into a field and multiple threads incorrectly raced to access it, a torn read/write could result in violating type safety due to ObjectIsTask reading the wrong value for the associated object. This commit changes the implementation to only use the single object field to determine which paths to take, rather than factoring in a second field that may not be in sync. Signed-off-by: dotnet-bot-corefx-mirror <dotnet-bot@microsoft.com> * Fix Assert in ValueTask (dotnet/coreclr#17511) Signed-off-by: dotnet-bot-corefx-mirror <dotnet-bot@microsoft.com> * Add GetPinnableReference back to Span and ReadOnlySpan (#17504) Signed-off-by: dotnet-bot-corefx-mirror <dotnet-bot@microsoft.com> * Fix CoreRT build breaks Signed-off-by: dotnet-bot <dotnet-bot@microsoft.com> Signed-off-by: dotnet-bot-corefx-mirror <dotnet-bot@microsoft.com> * Remove MemoryManager.Length (dotnet/coreclr#17498) * Remove MemoryManager.Length * Feedback * XML comment nits Signed-off-by: dotnet-bot-corefx-mirror <dotnet-bot@microsoft.com>
diff --git a/src/Common/src/CoreLib/System/Gen2GcCallback.cs b/src/Common/src/CoreLib/System/Gen2GcCallback.cs
@@ -67,7 +67,7 @@ private void Setup(Func<object, bool> callback, object targetObj)
             }
 
             // Resurrect ourselves by re-registering for finalization.
-            if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload())
+            if (!Environment.HasShutdownStarted)
             {
                 GC.ReRegisterForFinalize(this);
             }
diff --git a/src/Common/src/CoreLib/System/ReadOnlySpan.Fast.cs b/src/Common/src/CoreLib/System/ReadOnlySpan.Fast.cs
@@ -149,6 +149,13 @@ public ref readonly T this[int index]
 #endif
         }
 
+        /// <summary>
+        /// Returns a reference to the 0th element of the Span. If the Span is empty, returns null reference.
+        /// It can be used for pinning and is required to support the use of span within a fixed statement.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public unsafe ref readonly T GetPinnableReference() => ref (_length != 0) ? ref _pointer.Value : ref Unsafe.AsRef<T>(null);
+
         /// <summary>
         /// Copies the contents of this read-only span into destination span. If the source
         /// and destinations overlap, this method behaves as if the original values in
diff --git a/src/Common/src/CoreLib/System/Runtime/CompilerServices/ConfiguredValueTaskAwaitable.cs b/src/Common/src/CoreLib/System/Runtime/CompilerServices/ConfiguredValueTaskAwaitable.cs
@@ -59,55 +59,64 @@ public bool IsCompleted
             /// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable"/>.</summary>
             public void OnCompleted(Action continuation)
             {
-                if (_value.ObjectIsTask)
+                object obj = _value._obj;
+                Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);
+
+                if (obj is Task t)
                 {
-                    _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
+                    t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
                 }
-                else if (_value._obj != null)
+                else if (obj != null)
                 {
-                    _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
+                    Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
                         ValueTaskSourceOnCompletedFlags.FlowExecutionContext |
-                            (_value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));
+                            (_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));
                 }
                 else
                 {
-                    ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
+                    ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
                 }
             }
 
             /// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable"/>.</summary>
             public void UnsafeOnCompleted(Action continuation)
             {
-                if (_value.ObjectIsTask)
+                object obj = _value._obj;
+                Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);
+
+                if (obj is Task t)
                 {
-                    _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
+                    t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
                 }
-                else if (_value._obj != null)
+                else if (obj != null)
                 {
-                    _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
-                        _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
+                    Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
+                        _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
                 }
                 else
                 {
-                    ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
+                    ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
                 }
             }
 
 #if CORECLR
             void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
             {
-                if (_value.ObjectIsTask)
+                object obj = _value._obj;
+                Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);
+
+                if (obj is Task t)
                 {
-                    TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, _value.ContinueOnCapturedContext);
+                    TaskAwaiter.UnsafeOnCompletedInternal(t, box, _value._continueOnCapturedContext);
                 }
-                else if (_value._obj != null)
+                else if (obj != null)
                 {
-                    _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,
-                        _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
+                    Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,
+                        _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
                 }
                 else
                 {
-                    TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value.ContinueOnCapturedContext);
+                    TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);
                 }
             }
 #endif
@@ -161,55 +170,64 @@ public bool IsCompleted
             /// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable{TResult}"/>.</summary>
             public void OnCompleted(Action continuation)
             {
-                if (_value.ObjectIsTask)
+                object obj = _value._obj;
+                Debug.Assert(obj == null || obj is Task<TResult> || obj is IValueTaskSource<TResult>);
+
+                if (obj is Task<TResult> t)
                 {
-                    _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
+                    t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
                 }
-                else if (_value._obj != null)
+                else if (obj != null)
                 {
-                    _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
+                    Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
                         ValueTaskSourceOnCompletedFlags.FlowExecutionContext |
-                            (_value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));
+                            (_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));
                 }
                 else
                 {
-                    ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
+                    ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
                 }
             }
 
             /// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable{TResult}"/>.</summary>
             public void UnsafeOnCompleted(Action continuation)
             {
-                if (_value.ObjectIsTask)
+                object obj = _value._obj;
+                Debug.Assert(obj == null || obj is Task<TResult> || obj is IValueTaskSource<TResult>);
+
+                if (obj is Task<TResult> t)
                 {
-                    _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
+                    t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
                 }
-                else if (_value._obj != null)
+                else if (obj != null)
                 {
-                    _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
-                        _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
+                    Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
+                        _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
                 }
                 else
                 {
-                    ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
+                    ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
                 }
             }
 
 #if CORECLR
             void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
             {
-                if (_value.ObjectIsTask)
+                object obj = _value._obj;
+                Debug.Assert(obj == null || obj is Task<TResult> || obj is IValueTaskSource<TResult>);
+
+                if (obj is Task<TResult> t)
                 {
-                    TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, _value.ContinueOnCapturedContext);
+                    TaskAwaiter.UnsafeOnCompletedInternal(t, box, _value._continueOnCapturedContext);
                 }
-                else if (_value._obj != null)
+                else if (obj != null)
                 {
-                    _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,
-                        _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
+                    Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,
+                        _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
                 }
                 else
                 {
-                    TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value.ContinueOnCapturedContext);
+                    TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);
                 }
             }
 #endif
diff --git a/src/Common/src/CoreLib/System/Runtime/CompilerServices/ValueTaskAwaiter.cs b/src/Common/src/CoreLib/System/Runtime/CompilerServices/ValueTaskAwaiter.cs
@@ -6,6 +6,10 @@
 using System.Threading.Tasks;
 using System.Threading.Tasks.Sources;
 
+#if !netstandard
+using Internal.Runtime.CompilerServices;
+#endif
+
 namespace System.Runtime.CompilerServices
 {
     /// <summary>Provides an awaiter for a <see cref="ValueTask"/>.</summary>
@@ -48,13 +52,16 @@ public bool IsCompleted
         /// <summary>Schedules the continuation action for this ValueTask.</summary>
         public void OnCompleted(Action continuation)
         {
-            if (_value.ObjectIsTask)
+            object obj = _value._obj;
+            Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);
+
+            if (obj is Task t)
             {
-                _value.UnsafeGetTask().GetAwaiter().OnCompleted(continuation);
+                t.GetAwaiter().OnCompleted(continuation);
             }
-            else if (_value._obj != null)
+            else if (obj != null)
             {
-                _value.UnsafeGetValueTaskSource().OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
+                Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
             }
             else
             {
@@ -65,13 +72,16 @@ public void OnCompleted(Action continuation)
         /// <summary>Schedules the continuation action for this ValueTask.</summary>
         public void UnsafeOnCompleted(Action continuation)
         {
-            if (_value.ObjectIsTask)
+            object obj = _value._obj;
+            Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);
+
+            if (obj is Task t)
             {
-                _value.UnsafeGetTask().GetAwaiter().UnsafeOnCompleted(continuation);
+                t.GetAwaiter().UnsafeOnCompleted(continuation);
             }
-            else if (_value._obj != null)
+            else if (obj != null)
             {
-                _value.UnsafeGetValueTaskSource().OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
+                Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
             }
             else
             {
@@ -82,13 +92,16 @@ public void UnsafeOnCompleted(Action continuation)
 #if CORECLR
         void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
         {
-            if (_value.ObjectIsTask)
+            object obj = _value._obj;
+            Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);
+
+            if (obj is Task t)
             {
-                TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, continueOnCapturedContext: true);
+                TaskAwaiter.UnsafeOnCompletedInternal(t, box, continueOnCapturedContext: true);
             }
-            else if (_value._obj != null)
+            else if (obj != null)
             {
-                _value.UnsafeGetValueTaskSource().OnCompleted(s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
+                Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
             }
             else
             {
@@ -139,13 +152,16 @@ public bool IsCompleted
         /// <summary>Schedules the continuation action for this ValueTask.</summary>
         public void OnCompleted(Action continuation)
         {
-            if (_value.ObjectIsTask)
+            object obj = _value._obj;
+            Debug.Assert(obj == null || obj is Task<TResult> || obj is IValueTaskSource<TResult>);
+
+            if (obj is Task<TResult> t)
             {
-                _value.UnsafeGetTask().GetAwaiter().OnCompleted(continuation);
+                t.GetAwaiter().OnCompleted(continuation);
             }
-            else if (_value._obj != null)
+            else if (obj != null)
             {
-                _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
+                Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
             }
             else
             {
@@ -156,13 +172,16 @@ public void OnCompleted(Action continuation)
         /// <summary>Schedules the continuation action for this ValueTask.</summary>
         public void UnsafeOnCompleted(Action continuation)
         {
-            if (_value.ObjectIsTask)
+            object obj = _value._obj;
+            Debug.Assert(obj == null || obj is Task<TResult> || obj is IValueTaskSource<TResult>);
+
+            if (obj is Task<TResult> t)
             {
-                _value.UnsafeGetTask().GetAwaiter().UnsafeOnCompleted(continuation);
+                t.GetAwaiter().UnsafeOnCompleted(continuation);
             }
-            else if (_value._obj != null)
+            else if (obj != null)
             {
-                _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
+                Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
             }
             else
             {
@@ -173,13 +192,16 @@ public void UnsafeOnCompleted(Action continuation)
 #if CORECLR
         void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
         {
-            if (_value.ObjectIsTask)
+            object obj = _value._obj;
+            Debug.Assert(obj == null || obj is Task<TResult> || obj is IValueTaskSource<TResult>);
+
+            if (obj is Task<TResult> t)
             {
-                TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, continueOnCapturedContext: true);
+                TaskAwaiter.UnsafeOnCompletedInternal(t, box, continueOnCapturedContext: true);
             }
-            else if (_value._obj != null)
+            else if (obj != null)
             {
-                _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
+                Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
             }
             else
             {
diff --git a/src/Common/src/CoreLib/System/Runtime/ConstrainedExecution/CriticalFinalizerObject.cs b/src/Common/src/CoreLib/System/Runtime/ConstrainedExecution/CriticalFinalizerObject.cs
@@ -2,22 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-//
 /*============================================================
 **
 **
-**
 ** Deriving from this class will cause any finalizer you define to be critical
 ** (i.e. the finalizer is guaranteed to run, won't be aborted by the host and is
 ** run after the finalizers of other objects collected at the same time).
 **
-**
 ** 
 ===========================================================*/
 
-using System;
-using System.Runtime.InteropServices;
-
 namespace System.Runtime.ConstrainedExecution
 {
     public abstract class CriticalFinalizerObject
@@ -26,6 +20,7 @@ protected CriticalFinalizerObject()
         {
         }
 
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1821:RemoveEmptyFinalizers")]
         ~CriticalFinalizerObject()
         {
         }
diff --git a/src/Common/src/CoreLib/System/Span.Fast.cs b/src/Common/src/CoreLib/System/Span.Fast.cs
diff --git a/src/Common/src/CoreLib/System/Threading/Tasks/ValueTask.cs b/src/Common/src/CoreLib/System/Threading/Tasks/ValueTask.cs

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ private void Setup(Func<object, bool> callback, object targetObj)`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`// Resurrect ourselves by re-registering for finalization.`
`70`		`- if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload())`
	`70`	`+ if (!Environment.HasShutdownStarted)`
`71`	`71`	`{`
`72`	`72`	`GC.ReRegisterForFinalize(this);`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,55 +59,64 @@ public bool IsCompleted`
`59`	`59`	`/// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable"/>.</summary>`
`60`	`60`	`public void OnCompleted(Action continuation)`
`61`	`61`	`{`
`62`		`- if (_value.ObjectIsTask)`
	`62`	`+ object obj = _value._obj;`
	`63`	`+ Debug.Assert(obj == null \|\| obj is Task \|\| obj is IValueTaskSource);`
	`64`	`+`
	`65`	`+ if (obj is Task t)`
`63`	`66`	`{`
`64`		`- _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
	`67`	`+ t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
`65`	`68`	`}`
`66`		`- else if (_value._obj != null)`
	`69`	`+ else if (obj != null)`
`67`	`70`	`{`
`68`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
	`71`	`+ Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
`69`	`72`	`ValueTaskSourceOnCompletedFlags.FlowExecutionContext \|`
`70`		`- (_value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));`
	`73`	`+ (_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));`
`71`	`74`	`}`
`72`	`75`	`else`
`73`	`76`	`{`
`74`		`- ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
	`77`	`+ ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
`75`	`78`	`}`
`76`	`79`	`}`
`77`	`80`
`78`	`81`	`/// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable"/>.</summary>`
`79`	`82`	`public void UnsafeOnCompleted(Action continuation)`
`80`	`83`	`{`
`81`		`- if (_value.ObjectIsTask)`
	`84`	`+ object obj = _value._obj;`
	`85`	`+ Debug.Assert(obj == null \|\| obj is Task \|\| obj is IValueTaskSource);`
	`86`	`+`
	`87`	`+ if (obj is Task t)`
`82`	`88`	`{`
`83`		`- _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
	`89`	`+ t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
`84`	`90`	`}`
`85`		`- else if (_value._obj != null)`
	`91`	`+ else if (obj != null)`
`86`	`92`	`{`
`87`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
`88`		`- _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
	`93`	`+ Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
	`94`	`+ _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
`89`	`95`	`}`
`90`	`96`	`else`
`91`	`97`	`{`
`92`		`- ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
	`98`	`+ ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
`93`	`99`	`}`
`94`	`100`	`}`
`95`	`101`
`96`	`102`	`#if CORECLR`
`97`	`103`	`void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)`
`98`	`104`	`{`
`99`		`- if (_value.ObjectIsTask)`
	`105`	`+ object obj = _value._obj;`
	`106`	`+ Debug.Assert(obj == null \|\| obj is Task \|\| obj is IValueTaskSource);`
	`107`	`+`
	`108`	`+ if (obj is Task t)`
`100`	`109`	`{`
`101`		`- TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, _value.ContinueOnCapturedContext);`
	`110`	`+ TaskAwaiter.UnsafeOnCompletedInternal(t, box, _value._continueOnCapturedContext);`
`102`	`111`	`}`
`103`		`- else if (_value._obj != null)`
	`112`	`+ else if (obj != null)`
`104`	`113`	`{`
`105`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,`
`106`		`- _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
	`114`	`+ Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,`
	`115`	`+ _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
`107`	`116`	`}`
`108`	`117`	`else`
`109`	`118`	`{`
`110`		`- TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value.ContinueOnCapturedContext);`
	`119`	`+ TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);`
`111`	`120`	`}`
`112`	`121`	`}`
`113`	`122`	`#endif`
`@@ -161,55 +170,64 @@ public bool IsCompleted`
`161`	`170`	`/// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable{TResult}"/>.</summary>`
`162`	`171`	`public void OnCompleted(Action continuation)`
`163`	`172`	`{`
`164`		`- if (_value.ObjectIsTask)`
	`173`	`+ object obj = _value._obj;`
	`174`	`+ Debug.Assert(obj == null \|\| obj is Task<TResult> \|\| obj is IValueTaskSource<TResult>);`
	`175`	`+`
	`176`	`+ if (obj is Task<TResult> t)`
`165`	`177`	`{`
`166`		`- _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
	`178`	`+ t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
`167`	`179`	`}`
`168`		`- else if (_value._obj != null)`
	`180`	`+ else if (obj != null)`
`169`	`181`	`{`
`170`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
	`182`	`+ Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
`171`	`183`	`ValueTaskSourceOnCompletedFlags.FlowExecutionContext \|`
`172`		`- (_value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));`
	`184`	`+ (_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));`
`173`	`185`	`}`
`174`	`186`	`else`
`175`	`187`	`{`
`176`		`- ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
	`188`	`+ ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);`
`177`	`189`	`}`
`178`	`190`	`}`
`179`	`191`
`180`	`192`	`/// <summary>Schedules the continuation action for the <see cref="ConfiguredValueTaskAwaitable{TResult}"/>.</summary>`
`181`	`193`	`public void UnsafeOnCompleted(Action continuation)`
`182`	`194`	`{`
`183`		`- if (_value.ObjectIsTask)`
	`195`	`+ object obj = _value._obj;`
	`196`	`+ Debug.Assert(obj == null \|\| obj is Task<TResult> \|\| obj is IValueTaskSource<TResult>);`
	`197`	`+`
	`198`	`+ if (obj is Task<TResult> t)`
`184`	`199`	`{`
`185`		`- _value.UnsafeGetTask().ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
	`200`	`+ t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
`186`	`201`	`}`
`187`		`- else if (_value._obj != null)`
	`202`	`+ else if (obj != null)`
`188`	`203`	`{`
`189`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
`190`		`- _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
	`204`	`+ Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,`
	`205`	`+ _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
`191`	`206`	`}`
`192`	`207`	`else`
`193`	`208`	`{`
`194`		`- ValueTask.CompletedTask.ConfigureAwait(_value.ContinueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
	`209`	`+ ValueTask.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);`
`195`	`210`	`}`
`196`	`211`	`}`
`197`	`212`
`198`	`213`	`#if CORECLR`
`199`	`214`	`void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)`
`200`	`215`	`{`
`201`		`- if (_value.ObjectIsTask)`
	`216`	`+ object obj = _value._obj;`
	`217`	`+ Debug.Assert(obj == null \|\| obj is Task<TResult> \|\| obj is IValueTaskSource<TResult>);`
	`218`	`+`
	`219`	`+ if (obj is Task<TResult> t)`
`202`	`220`	`{`
`203`		`- TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, _value.ContinueOnCapturedContext);`
	`221`	`+ TaskAwaiter.UnsafeOnCompletedInternal(t, box, _value._continueOnCapturedContext);`
`204`	`222`	`}`
`205`		`- else if (_value._obj != null)`
	`223`	`+ else if (obj != null)`
`206`	`224`	`{`
`207`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,`
`208`		`- _value.ContinueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
	`225`	`+ Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token,`
	`226`	`+ _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);`
`209`	`227`	`}`
`210`	`228`	`else`
`211`	`229`	`{`
`212`		`- TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value.ContinueOnCapturedContext);`
	`230`	`+ TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);`
`213`	`231`	`}`
`214`	`232`	`}`
`215`	`233`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,10 @@`
`6`	`6`	`using System.Threading.Tasks;`
`7`	`7`	`using System.Threading.Tasks.Sources;`
`8`	`8`
	`9`	`+#if !netstandard`
	`10`	`+using Internal.Runtime.CompilerServices;`
	`11`	`+#endif`
	`12`	`+`
`9`	`13`	`namespace System.Runtime.CompilerServices`
`10`	`14`	`{`
`11`	`15`	`/// <summary>Provides an awaiter for a <see cref="ValueTask"/>.</summary>`
`@@ -48,13 +52,16 @@ public bool IsCompleted`
`48`	`52`	`/// <summary>Schedules the continuation action for this ValueTask.</summary>`
`49`	`53`	`public void OnCompleted(Action continuation)`
`50`	`54`	`{`
`51`		`- if (_value.ObjectIsTask)`
	`55`	`+ object obj = _value._obj;`
	`56`	`+ Debug.Assert(obj == null \|\| obj is Task \|\| obj is IValueTaskSource);`
	`57`	`+`
	`58`	`+ if (obj is Task t)`
`52`	`59`	`{`
`53`		`- _value.UnsafeGetTask().GetAwaiter().OnCompleted(continuation);`
	`60`	`+ t.GetAwaiter().OnCompleted(continuation);`
`54`	`61`	`}`
`55`		`- else if (_value._obj != null)`
	`62`	`+ else if (obj != null)`
`56`	`63`	`{`
`57`		`- _value.UnsafeGetValueTaskSource().OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext \| ValueTaskSourceOnCompletedFlags.FlowExecutionContext);`
	`64`	`+ Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext \| ValueTaskSourceOnCompletedFlags.FlowExecutionContext);`
`58`	`65`	`}`
`59`	`66`	`else`
`60`	`67`	`{`
`@@ -65,13 +72,16 @@ public void OnCompleted(Action continuation)`
`65`	`72`	`/// <summary>Schedules the continuation action for this ValueTask.</summary>`
`66`	`73`	`public void UnsafeOnCompleted(Action continuation)`
`67`	`74`	`{`
`68`		`- if (_value.ObjectIsTask)`
	`75`	`+ object obj = _value._obj;`
	`76`	`+ Debug.Assert(obj == null \|\| obj is Task \|\| obj is IValueTaskSource);`
	`77`	`+`
	`78`	`+ if (obj is Task t)`
`69`	`79`	`{`
`70`		`- _value.UnsafeGetTask().GetAwaiter().UnsafeOnCompleted(continuation);`
	`80`	`+ t.GetAwaiter().UnsafeOnCompleted(continuation);`
`71`	`81`	`}`
`72`		`- else if (_value._obj != null)`
	`82`	`+ else if (obj != null)`
`73`	`83`	`{`
`74`		`- _value.UnsafeGetValueTaskSource().OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
	`84`	`+ Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
`75`	`85`	`}`
`76`	`86`	`else`
`77`	`87`	`{`
`@@ -82,13 +92,16 @@ public void UnsafeOnCompleted(Action continuation)`
`82`	`92`	`#if CORECLR`
`83`	`93`	`void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)`
`84`	`94`	`{`
`85`		`- if (_value.ObjectIsTask)`
	`95`	`+ object obj = _value._obj;`
	`96`	`+ Debug.Assert(obj == null \|\| obj is Task \|\| obj is IValueTaskSource);`
	`97`	`+`
	`98`	`+ if (obj is Task t)`
`86`	`99`	`{`
`87`		`- TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, continueOnCapturedContext: true);`
	`100`	`+ TaskAwaiter.UnsafeOnCompletedInternal(t, box, continueOnCapturedContext: true);`
`88`	`101`	`}`
`89`		`- else if (_value._obj != null)`
	`102`	`+ else if (obj != null)`
`90`	`103`	`{`
`91`		`- _value.UnsafeGetValueTaskSource().OnCompleted(s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
	`104`	`+ Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
`92`	`105`	`}`
`93`	`106`	`else`
`94`	`107`	`{`
`@@ -139,13 +152,16 @@ public bool IsCompleted`
`139`	`152`	`/// <summary>Schedules the continuation action for this ValueTask.</summary>`
`140`	`153`	`public void OnCompleted(Action continuation)`
`141`	`154`	`{`
`142`		`- if (_value.ObjectIsTask)`
	`155`	`+ object obj = _value._obj;`
	`156`	`+ Debug.Assert(obj == null \|\| obj is Task<TResult> \|\| obj is IValueTaskSource<TResult>);`
	`157`	`+`
	`158`	`+ if (obj is Task<TResult> t)`
`143`	`159`	`{`
`144`		`- _value.UnsafeGetTask().GetAwaiter().OnCompleted(continuation);`
	`160`	`+ t.GetAwaiter().OnCompleted(continuation);`
`145`	`161`	`}`
`146`		`- else if (_value._obj != null)`
	`162`	`+ else if (obj != null)`
`147`	`163`	`{`
`148`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext \| ValueTaskSourceOnCompletedFlags.FlowExecutionContext);`
	`164`	`+ Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext \| ValueTaskSourceOnCompletedFlags.FlowExecutionContext);`
`149`	`165`	`}`
`150`	`166`	`else`
`151`	`167`	`{`
`@@ -156,13 +172,16 @@ public void OnCompleted(Action continuation)`
`156`	`172`	`/// <summary>Schedules the continuation action for this ValueTask.</summary>`
`157`	`173`	`public void UnsafeOnCompleted(Action continuation)`
`158`	`174`	`{`
`159`		`- if (_value.ObjectIsTask)`
	`175`	`+ object obj = _value._obj;`
	`176`	`+ Debug.Assert(obj == null \|\| obj is Task<TResult> \|\| obj is IValueTaskSource<TResult>);`
	`177`	`+`
	`178`	`+ if (obj is Task<TResult> t)`
`160`	`179`	`{`
`161`		`- _value.UnsafeGetTask().GetAwaiter().UnsafeOnCompleted(continuation);`
	`180`	`+ t.GetAwaiter().UnsafeOnCompleted(continuation);`
`162`	`181`	`}`
`163`		`- else if (_value._obj != null)`
	`182`	`+ else if (obj != null)`
`164`	`183`	`{`
`165`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
	`184`	`+ Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
`166`	`185`	`}`
`167`	`186`	`else`
`168`	`187`	`{`
`@@ -173,13 +192,16 @@ public void UnsafeOnCompleted(Action continuation)`
`173`	`192`	`#if CORECLR`
`174`	`193`	`void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)`
`175`	`194`	`{`
`176`		`- if (_value.ObjectIsTask)`
	`195`	`+ object obj = _value._obj;`
	`196`	`+ Debug.Assert(obj == null \|\| obj is Task<TResult> \|\| obj is IValueTaskSource<TResult>);`
	`197`	`+`
	`198`	`+ if (obj is Task<TResult> t)`
`177`	`199`	`{`
`178`		`- TaskAwaiter.UnsafeOnCompletedInternal(_value.UnsafeGetTask(), box, continueOnCapturedContext: true);`
	`200`	`+ TaskAwaiter.UnsafeOnCompletedInternal(t, box, continueOnCapturedContext: true);`
`179`	`201`	`}`
`180`		`- else if (_value._obj != null)`
	`202`	`+ else if (obj != null)`
`181`	`203`	`{`
`182`		`- _value.UnsafeGetValueTaskSource().OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
	`204`	`+ Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);`
`183`	`205`	`}`
`184`	`206`	`else`
`185`	`207`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,22 +2,16 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`	`// See the LICENSE file in the project root for more information.`
`4`	`4`
`5`		`-//`
`6`	`5`	`/*============================================================`
`7`	`6`	`**`
`8`	`7`	`**`
`9`		`-**`
`10`	`8`	`** Deriving from this class will cause any finalizer you define to be critical`
`11`	`9`	`** (i.e. the finalizer is guaranteed to run, won't be aborted by the host and is`
`12`	`10`	`** run after the finalizers of other objects collected at the same time).`
`13`	`11`	`**`
`14`		`-**`
`15`	`12`	`**`
`16`	`13`	`===========================================================*/`
`17`	`14`
`18`		`-using System;`
`19`		`-using System.Runtime.InteropServices;`
`20`		`-`
`21`	`15`	`namespace System.Runtime.ConstrainedExecution`
`22`	`16`	`{`
`23`	`17`	`public abstract class CriticalFinalizerObject`
`@@ -26,6 +20,7 @@ protected CriticalFinalizerObject()`
`26`	`20`	`{`
`27`	`21`	`}`
`28`	`22`
	`23`	`+ [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1821:RemoveEmptyFinalizers")]`
`29`	`24`	`~CriticalFinalizerObject()`
`30`	`25`	`{`
`31`	`26`	`}`