Fixed nullability annotations in Microsoft.Toolkit

Author: Sergio0694

Microsoft.Toolkit/Attributes/DoesNotReturnAttribute.cs

@@ -9,7 +9,7 @@ namespace System.Diagnostics.CodeAnalysis
     /// <summary>
     /// Applied to a method that will never return under any circumstance.
     /// </summary>
-    /// <remarks>Internal copy of the .NET Standard 2.1 attribute.</remarks>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(AttributeTargets.Method, Inherited = false)]
     internal sealed class DoesNotReturnAttribute : Attribute
     {

Microsoft.Toolkit/Attributes/DoesNotReturnIfAttribute.cs

@@ -10,7 +10,7 @@ namespace System.Diagnostics.CodeAnalysis
     /// Specifies that a given <see cref="ParameterValue"/> also indicates
     /// whether the method will not return (eg. throw an exception).
     /// </summary>
-    /// <remarks>Internal copy of the .NET Standard 2.1 attribute.</remarks>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(AttributeTargets.Parameter)]
     internal sealed class DoesNotReturnIfAttribute : Attribute
     {

Microsoft.Toolkit/Attributes/MaybeNullAttribute.cs

@@ -9,6 +9,7 @@ namespace System.Diagnostics.CodeAnalysis
     /// <summary>
     /// Specifies that an output may be <see langword="null"/> even if the corresponding type disallows it.
     /// </summary>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue)]
     internal sealed class MaybeNullAttribute : Attribute
     {

Microsoft.Toolkit/Attributes/MaybeNullWhenAttribute.cs

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NETSTANDARD2_1_OR_GREATER
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that when a method returns <see cref="ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.
+    /// </summary>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal sealed class MaybeNullWhenAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MaybeNullWhenAttribute"/> class.
+        /// </summary>
+        /// <param name="returnValue">The return value condition. If the method returns this value, the associated parameter may be null.</param>
+        public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        /// <summary>
+        /// Gets a value indicating whether the value may be <see langword="null"/> depending on the return value.
+        /// </summary>
+        public bool ReturnValue { get; }
+    }
+}
+
+#endif

Microsoft.Toolkit/Attributes/NotNullAttribute.cs

@@ -10,7 +10,7 @@ namespace System.Diagnostics.CodeAnalysis
     /// Specifies that an output will not be <see langword="null"/> even if the corresponding type allows it.
     /// Specifies that an input argument was not <see langword="null"/> when the call returns.
     /// </summary>
-    /// <remarks>Internal copy of the .NET Standard 2.1 attribute.</remarks>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue)]
     internal sealed class NotNullAttribute : Attribute
     {

Microsoft.Toolkit/Attributes/NotNullIfNotNullAttribute.cs

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NETSTANDARD2_1_OR_GREATER
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that the output will be non-null if the named parameter is non-null.
+    /// </summary>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
+    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
+    internal sealed class NotNullIfNotNullAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NotNullIfNotNullAttribute"/> class.
+        /// </summary>
+        /// <param name="parameterName">The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null.</param>
+        public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName;
+
+        /// <summary>
+        /// Gets the associated parameter name.
+        /// </summary>
+        public string ParameterName { get; }
+    }
+}
+
+#endif

Microsoft.Toolkit/Attributes/NotNullWhenAttribute.cs

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NETSTANDARD2_1_OR_GREATER
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.
+    /// </summary>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NotNullWhenAttribute"/> class.
+        /// </summary>
+        /// <param name="returnValue">The return value condition. If the method returns this value, the associated parameter will not be null.</param>
+        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        /// <summary>
+        /// Gets a value indicating whether the annotated variable is not <see langword="null"/>.
+        /// </summary>
+        public bool ReturnValue { get; }
+    }
+}
+
+#endif

Microsoft.Toolkit/Attributes/SkipLocalsInitAttribute.cs

@@ -9,7 +9,7 @@ namespace System.Runtime.CompilerServices
     /// <summary>
     /// Used to indicate to the compiler that the <c>.locals init</c> flag should not be set in method headers.
     /// </summary>
-    /// <remarks>Internal copy of the .NET 5 attribute.</remarks>
+    /// <remarks>Internal copy from the BCL attribute.</remarks>
     [AttributeUsage(
         AttributeTargets.Module |
         AttributeTargets.Class |

Microsoft.Toolkit/Collections/ObservableGroup.cs

@@ -18,6 +18,7 @@ namespace Microsoft.Toolkit.Collections
     /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
     [DebuggerDisplay("Key = {Key}, Count = {Count}")]
     public class ObservableGroup<TKey, TValue> : ObservableCollection<TValue>, IGrouping<TKey, TValue>, IReadOnlyObservableGroup
+        where TKey : notnull
     {
         /// <summary>
         /// The cached <see cref="PropertyChangedEventArgs"/> for <see cref="Key"/>
@@ -30,7 +31,7 @@ public class ObservableGroup<TKey, TValue> : ObservableCollection<TValue>, IGrou
         /// <param name="key">The key for the group.</param>
         public ObservableGroup(TKey key)
         {
-            Key = key;
+            this.key = key;
         }
 
         /// <summary>
@@ -40,7 +41,7 @@ public ObservableGroup(TKey key)
         public ObservableGroup(IGrouping<TKey, TValue> grouping)
             : base(grouping)
         {
-            Key = grouping.Key;
+            this.key = grouping.Key;
         }
 
         /// <summary>
@@ -51,7 +52,7 @@ public ObservableGroup(IGrouping<TKey, TValue> grouping)
         public ObservableGroup(TKey key, IEnumerable<TValue> collection)
             : base(collection)
         {
-            Key = key;
+            this.key = key;
         }
 
         private TKey key;
@@ -64,7 +65,7 @@ public TKey Key
             get => this.key;
             set
             {
-                if (!EqualityComparer<TKey>.Default.Equals(this.key, value))
+                if (!EqualityComparer<TKey>.Default.Equals(this.key!, value))
                 {
                     this.key = value;
 

Microsoft.Toolkit/Collections/ObservableGroupedCollection.cs

@@ -4,11 +4,10 @@
 
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
 
-#nullable enable
-
 namespace Microsoft.Toolkit.Collections
 {
     /// <summary>
@@ -17,6 +16,7 @@ namespace Microsoft.Toolkit.Collections
     /// <typeparam name="TKey">The type of the group key.</typeparam>
     /// <typeparam name="TValue">The type of the items in the collection.</typeparam>
     public sealed class ObservableGroupedCollection<TKey, TValue> : ObservableCollection<ObservableGroup<TKey, TValue>>
+        where TKey : notnull
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ObservableGroupedCollection{TKey, TValue}"/> class.
@@ -30,7 +30,7 @@ public ObservableGroupedCollection()
         /// </summary>
         /// <param name="collection">The initial data to add in the grouped collection.</param>
         public ObservableGroupedCollection(IEnumerable<IGrouping<TKey, TValue>> collection)
-            : base(collection.Select(c => new ObservableGroup<TKey, TValue>(c)))
+            : base(collection.Select(static c => new ObservableGroup<TKey, TValue>(c)))
         {
         }
 
@@ -40,7 +40,7 @@ public ObservableGroupedCollection(IEnumerable<IGrouping<TKey, TValue>> collecti
         /// <param name="list">The resulting <see cref="List{T}"/>, if one was in use.</param>
         /// <returns>Whether or not a <see cref="List{T}"/> instance has been found.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal bool TryGetList(out List<ObservableGroup<TKey, TValue>>? list)
+        internal bool TryGetList([NotNullWhen(true)] out List<ObservableGroup<TKey, TValue>>? list)
         {
             list = Items as List<ObservableGroup<TKey, TValue>>;