Update annotations with latest usages

ppy · Nov 27, 2024 · 9c9b8ad · 9c9b8ad
1 parent 6804bda
commit 9c9b8ad
Show file tree

Hide file tree

Showing 4 changed files with 15 additions and 15 deletions.
diff --git a/osu.Framework/Bindables/AggregateBindable.cs b/osu.Framework/Bindables/AggregateBindable.cs
@@ -83,7 +83,7 @@ public void RemoveSource(IBindable<T> bindable)
             return null;
         }
 
-        private void recalculateAggregate(ValueChangedEvent<T> obj = null)
+        private void recalculateAggregate(ValueChangedEvent<T>? obj = null)
         {
             T calculated = initialValue;
 

diff --git a/osu.Framework/Bindables/Bindable.cs b/osu.Framework/Bindables/Bindable.cs
@@ -247,7 +247,7 @@ private void addWeakReference(WeakReference<Bindable<T>> weakReference)
         /// </summary>
         /// <param name="input">The input which is to be parsed.</param>
         /// <param name="provider">An object that provides culture-specific formatting information about <paramref name="input"/>.</param>
-        public virtual void Parse(object input, IFormatProvider provider)
+        public virtual void Parse(object? input, IFormatProvider provider)
         {
             switch (input)
             {
@@ -261,7 +261,7 @@ public virtual void Parse(object input, IFormatProvider provider)
                     // Nullable value types and reference types (annotated or not) are allowed to be initialised with `null`.
                     if (typeof(T).IsNullable() || typeof(T).IsClass)
                     {
-                        Value = default;
+                        Value = default!;
                         break;
                     }
 
@@ -281,7 +281,7 @@ public virtual void Parse(object input, IFormatProvider provider)
                         // Nullable value types and reference types are initialised to `null` on empty strings.
                         if (typeof(T).IsNullable() || typeof(T).IsClass)
                         {
-                            Value = default;
+                            Value = default!;
                             break;
                         }
 

diff --git a/osu.Framework/Bindables/BindableList.cs b/osu.Framework/Bindables/BindableList.cs
@@ -418,7 +418,7 @@ int IList.Add(object? value)
         /// <param name="input">The input which is to be parsed.</param>
         /// <param name="provider">Not valid for <see cref="BindableList{T}"/>.</param>
         /// <exception cref="InvalidOperationException">Thrown if this <see cref="BindableList{T}"/> is <see cref="Disabled"/>.</exception>
-        public void Parse(object input, IFormatProvider provider)
+        public void Parse(object? input, IFormatProvider provider)
         {
             ensureMutationAllowed();
 

diff --git a/osu.Framework/Bindables/RangeConstrainedBindable.cs b/osu.Framework/Bindables/RangeConstrainedBindable.cs
@@ -90,25 +90,25 @@ public float NormalizedValue
         private static float convertToSingle(T val)
         {
             if (typeof(T) == typeof(sbyte))
-                return Convert.ToSingle((sbyte)(object)val);
+                return Convert.ToSingle((sbyte)(object)val!);
             if (typeof(T) == typeof(byte))
-                return Convert.ToSingle((byte)(object)val);
+                return Convert.ToSingle((byte)(object)val!);
             if (typeof(T) == typeof(short))
-                return Convert.ToSingle((short)(object)val);
+                return Convert.ToSingle((short)(object)val!);
             if (typeof(T) == typeof(ushort))
-                return Convert.ToSingle((ushort)(object)val);
+                return Convert.ToSingle((ushort)(object)val!);
             if (typeof(T) == typeof(int))
-                return Convert.ToSingle((int)(object)val);
+                return Convert.ToSingle((int)(object)val!);
             if (typeof(T) == typeof(uint))
-                return Convert.ToSingle((uint)(object)val);
+                return Convert.ToSingle((uint)(object)val!);
             if (typeof(T) == typeof(long))
-                return Convert.ToSingle((long)(object)val);
+                return Convert.ToSingle((long)(object)val!);
             if (typeof(T) == typeof(ulong))
-                return Convert.ToSingle((ulong)(object)val);
+                return Convert.ToSingle((ulong)(object)val!);
             if (typeof(T) == typeof(double))
-                return Convert.ToSingle((double)(object)val);
+                return Convert.ToSingle((double)(object)val!);
             if (typeof(T) == typeof(float))
-                return (float)(object)val;
+                return (float)(object)val!;
 
             throw new InvalidOperationException();
         }