Consider DBNull.Value and NullString.Value the same as $null when comparing with $null and casting to bool (PowerShell#9794)

- Adds `LanguagePrimitives.IsNullLike()` method to account for `DBNull.Value` and `NullString.Value` so that they can be considered the same as a null value where sensible in PowerShell.
- Updates `-ne` and `-eq` binders to treat `DBNull.Value` and `NullString.Value` as equal to null/AutomationNull.
- Update code paths for comparing objects in LanguagePrimitives to ensure consistency with how the `-eq` and `-ne` binders work when calling LanguagePrimitives methods to do the comparisons.
- Make `LanguagePrimitives.IsNull()` and `LanguagePrimitives.IsNullLike()` public methods.
- Added tests for null behaviours in `NullRepresentatives.Tests.ps1`

Author: vexx32

src/System.Management.Automation/engine/LanguagePrimitives.cs

@@ -593,9 +593,7 @@ public static PSDataCollection<PSObject> GetPSDataCollection(object inputValue)
         /// <param name="second">Object to compare first to.</param>
         /// <returns>True if first is equal to the second.</returns>
         public static new bool Equals(object first, object second)
-        {
-            return Equals(first, second, false, CultureInfo.InvariantCulture);
-        }
+            => Equals(first, second, false, CultureInfo.InvariantCulture);
 
         /// <summary>
         /// Used to compare two objects for equality converting the second to the type of the first, if required.
@@ -606,9 +604,7 @@ public static PSDataCollection<PSObject> GetPSDataCollection(object inputValue)
         /// to specify the type of string comparison </param>
         /// <returns>True if first is equal to the second.</returns>
         public static bool Equals(object first, object second, bool ignoreCase)
-        {
-            return Equals(first, second, ignoreCase, CultureInfo.InvariantCulture);
-        }
+            => Equals(first, second, ignoreCase, CultureInfo.InvariantCulture);
 
         /// <summary>
         /// Used to compare two objects for equality converting the second to the type of the first, if required.
@@ -646,25 +642,28 @@ public static bool Equals(object first, object second, bool ignoreCase, IFormatP
 
             if (first == null)
             {
-                if (second == null) return true;
-                return false;
+                return IsNullLike(second);
             }
 
             if (second == null)
             {
-                return false; // first is not null
+                return IsNullLike(first);
             }
 
-            string firstString = first as string;
             string secondString;
-            if (firstString != null)
+            if (first is string firstString)
             {
                 secondString = second as string ?? (string)LanguagePrimitives.ConvertTo(second, typeof(string), culture);
-                return (culture.CompareInfo.Compare(firstString, secondString,
-                                                    ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None) == 0);
+                return culture.CompareInfo.Compare(
+                    firstString,
+                    secondString,
+                    ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None) == 0;
             }
 
-            if (first.Equals(second)) return true;
+            if (first.Equals(second))
+            {
+                return true;
+            }
 
             Type firstType = first.GetType();
             Type secondType = second.GetType();
@@ -708,24 +707,24 @@ public static bool Equals(object first, object second, bool ignoreCase, IFormatP
         /// Helper method for [Try]Compare to determine object ordering with null.
         /// </summary>
         /// <param name="value">The numeric value to compare to null.</param>
-        /// <param name="numberIsRightHandSide">True if the number to compare is on the right hand side if the comparison.</param>
+        /// <param name="numberIsRightHandSide">True if the number to compare is on the right hand side in the comparison.</param>
         private static int CompareObjectToNull(object value, bool numberIsRightHandSide)
         {
             var i = numberIsRightHandSide ? -1 : 1;
 
             // If it's a positive number, including 0, it's greater than null
             // for everything else it's less than zero...
-            switch (value)
-            {
-                case Int16 i16: return Math.Sign(i16) < 0 ? -i : i;
-                case Int32 i32: return Math.Sign(i32) < 0 ? -i : i;
-                case Int64 i64: return Math.Sign(i64) < 0 ? -i : i;
-                case sbyte sby: return Math.Sign(sby) < 0 ? -i : i;
-                case float f: return Math.Sign(f) < 0 ? -i : i;
-                case double d: return Math.Sign(d) < 0 ? -i : i;
-                case decimal de: return Math.Sign(de) < 0 ? -i : i;
-                default: return i;
-            }
+            return value switch
+            {
+                Int16 i16 => Math.Sign(i16) < 0 ? -i : i,
+                Int32 i32 => Math.Sign(i32) < 0 ? -i : i,
+                Int64 i64 => Math.Sign(i64) < 0 ? -i : i,
+                sbyte s => Math.Sign(s) < 0 ? -i : i,
+                float f => Math.Sign(f) < 0 ? -i : i,
+                double d => Math.Sign(d) < 0 ? -i : i,
+                decimal m => Math.Sign(m) < 0 ? -i : i,
+                _ => IsNullLike(value) ? 0 : i
+            };
         }
 
         /// <summary>
@@ -741,9 +740,7 @@ private static int CompareObjectToNull(object value, bool numberIsRightHandSide)
         /// to the type of <paramref name="first"/>.
         /// </exception>
         public static int Compare(object first, object second)
-        {
-            return LanguagePrimitives.Compare(first, second, false, CultureInfo.InvariantCulture);
-        }
+            => LanguagePrimitives.Compare(first, second, false, CultureInfo.InvariantCulture);
 
         /// <summary>
         /// Compare first and second, converting second to the
@@ -759,9 +756,7 @@ public static int Compare(object first, object second)
         /// to the type of <paramref name="first"/>.
         /// </exception>
         public static int Compare(object first, object second, bool ignoreCase)
-        {
-            return LanguagePrimitives.Compare(first, second, ignoreCase, CultureInfo.InvariantCulture);
-        }
+            => LanguagePrimitives.Compare(first, second, ignoreCase, CultureInfo.InvariantCulture);
 
         /// <summary>
         /// Compare first and second, converting second to the
@@ -779,23 +774,20 @@ public static int Compare(object first, object second, bool ignoreCase)
         /// </exception>
         public static int Compare(object first, object second, bool ignoreCase, IFormatProvider formatProvider)
         {
-            if (formatProvider == null)
-            {
-                formatProvider = CultureInfo.InvariantCulture;
-            }
+            formatProvider ??= CultureInfo.InvariantCulture;
 
             var culture = formatProvider as CultureInfo;
             if (culture == null)
             {
-                throw PSTraceSource.NewArgumentException("formatProvider");
+                throw PSTraceSource.NewArgumentException(nameof(formatProvider));
             }
 
             first = PSObject.Base(first);
             second = PSObject.Base(second);
 
             if (first == null)
             {
-                return second == null ? 0 : CompareObjectToNull(second, true);
+                return CompareObjectToNull(second, true);
             }
 
             if (second == null)
@@ -805,7 +797,7 @@ public static int Compare(object first, object second, bool ignoreCase, IFormatP
 
             if (first is string firstString)
             {
-                string secondString = second as string;
+                var secondString = second as string;
                 if (secondString == null)
                 {
                     try
@@ -814,19 +806,26 @@ public static int Compare(object first, object second, bool ignoreCase, IFormatP
                     }
                     catch (PSInvalidCastException e)
                     {
-                        throw PSTraceSource.NewArgumentException("second", ExtendedTypeSystem.ComparisonFailure,
-                                                                 first.ToString(), second.ToString(), e.Message);
+                        throw PSTraceSource.NewArgumentException(
+                            nameof(second),
+                            ExtendedTypeSystem.ComparisonFailure,
+                            first.ToString(),
+                            second.ToString(),
+                            e.Message);
                     }
                 }
 
-                return culture.CompareInfo.Compare(firstString, secondString,
-                                                   ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
+                return culture.CompareInfo.Compare(
+                    firstString,
+                    secondString,
+                    ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
             }
 
             Type firstType = first.GetType();
             Type secondType = second.GetType();
             int firstIndex = LanguagePrimitives.TypeTableIndex(firstType);
             int secondIndex = LanguagePrimitives.TypeTableIndex(secondType);
+
             if ((firstIndex != -1) && (secondIndex != -1))
             {
                 return LanguagePrimitives.NumericCompare(first, second, firstIndex, secondIndex);
@@ -839,8 +838,12 @@ public static int Compare(object first, object second, bool ignoreCase, IFormatP
             }
             catch (PSInvalidCastException e)
             {
-                throw PSTraceSource.NewArgumentException("second", ExtendedTypeSystem.ComparisonFailure,
-                                                         first.ToString(), second.ToString(), e.Message);
+                throw PSTraceSource.NewArgumentException(
+                    nameof(second),
+                    ExtendedTypeSystem.ComparisonFailure,
+                    first.ToString(),
+                    second.ToString(),
+                    e.Message);
             }
 
             if (first is IComparable firstComparable)
@@ -855,7 +858,7 @@ public static int Compare(object first, object second, bool ignoreCase, IFormatP
 
             // At this point, we know that they aren't equal but we have no way of
             // knowing which should compare greater than the other so we throw an exception.
-            throw PSTraceSource.NewArgumentException("first", ExtendedTypeSystem.NotIcomparable, first.ToString());
+            throw PSTraceSource.NewArgumentException(nameof(first), ExtendedTypeSystem.NotIcomparable, first.ToString());
         }
 
         /// <summary>
@@ -868,9 +871,7 @@ public static int Compare(object first, object second, bool ignoreCase, IFormatP
         /// zero if it is greater or zero if they are the same.</param>
         /// <returns>True if the comparison was successful, false otherwise.</returns>
         public static bool TryCompare(object first, object second, out int result)
-        {
-            return TryCompare(first, second, ignoreCase: false, CultureInfo.InvariantCulture, out result);
-        }
+            => TryCompare(first, second, ignoreCase: false, CultureInfo.InvariantCulture, out result);
 
         /// <summary>
         /// Tries to compare first and second, converting second to the type of the first, if necessary.
@@ -882,9 +883,7 @@ public static bool TryCompare(object first, object second, out int result)
         /// <param name="result">Less than zero if first is smaller than second, more than zero if it is greater or zero if they are the same.</param>
         /// <returns>True if the comparison was successful, false otherwise.</returns>
         public static bool TryCompare(object first, object second, bool ignoreCase, out int result)
-        {
-            return TryCompare(first, second, ignoreCase, CultureInfo.InvariantCulture, out result);
-        }
+            => TryCompare(first, second, ignoreCase, CultureInfo.InvariantCulture, out result);
 
         /// <summary>
         /// Tries to compare first and second, converting second to the type of the first, if necessary.
@@ -900,10 +899,7 @@ public static bool TryCompare(object first, object second, bool ignoreCase, out
         public static bool TryCompare(object first, object second, bool ignoreCase, IFormatProvider formatProvider, out int result)
         {
             result = 0;
-            if (formatProvider == null)
-            {
-                formatProvider = CultureInfo.InvariantCulture;
-            }
+            formatProvider ??= CultureInfo.InvariantCulture;
 
             if (!(formatProvider is CultureInfo culture))
             {
@@ -988,8 +984,10 @@ public static bool TryCompare(object first, object second, bool ignoreCase, IFor
         public static bool IsTrue(object obj)
         {
             // null is a valid argument - it converts to false...
-            if (obj == null || obj == AutomationNull.Value)
+            if (IsNullLike(obj))
+            {
                 return false;
+            }
 
             obj = PSObject.Base(obj);
 
@@ -1015,8 +1013,7 @@ public static bool IsTrue(object obj)
             if (objType == typeof(SwitchParameter))
                 return ((SwitchParameter)obj).ToBool();
 
-            IList objectArray = obj as IList;
-            if (objectArray != null)
+            if (obj is IList objectArray)
             {
                 return IsTrue(objectArray);
             }
@@ -1061,15 +1058,20 @@ internal static bool IsTrue(IList objectArray)
             }
         }
 
+        /// <summary>
+        /// Internal routine that determines if an object meets any of our criteria for true null.
+        /// </summary>
+        /// <param name="obj">The object to test.</param>
+        /// <returns>True if the object is null.</returns>
+        public static bool IsNull(object obj) => obj == null || obj == AutomationNull.Value;
+
         /// <summary>
         /// Internal routine that determines if an object meets any of our criteria for null.
+        /// This method additionally checks for <see cref="NullString.Value"/> and <see cref="DBNull.Value"/>
         /// </summary>
         /// <param name="obj">The object to test.</param>
         /// <returns>True if the object is null.</returns>
-        internal static bool IsNull(object obj)
-        {
-            return (obj == null || obj == AutomationNull.Value);
-        }
+        public static bool IsNullLike(object obj) => obj == DBNull.Value || obj == NullString.Value || IsNull(obj);
 
         /// <summary>
         /// Auxiliary for the cases where we want a new PSObject or null.
@@ -3100,15 +3102,17 @@ private static object ConvertToVoid(object valueToConvert,
             return AutomationNull.Value;
         }
 
-        private static bool ConvertClassToBool(object valueToConvert,
-                                               Type resultType,
-                                               bool recursion,
-                                               PSObject originalValueToConvert,
-                                               IFormatProvider formatProvider,
-                                               TypeTable backupTable)
+        private static bool ConvertClassToBool(
+            object valueToConvert,
+            Type resultType,
+            bool recursion,
+            PSObject originalValueToConvert,
+            IFormatProvider formatProvider,
+            TypeTable backupTable)
         {
             typeConversion.WriteLine("Converting ref to boolean.");
-            return valueToConvert != null;
+            // Both NullString and DBNull should be treated the same as true nulls for the purposes of this conversion.
+            return !IsNullLike(valueToConvert);
         }
 
         private static bool ConvertValueToBool(object valueToConvert,
@@ -4724,10 +4728,11 @@ internal static IConversionData FigureConversion(object valueToConvert, Type res
         {
             PSObject valueAsPsObj;
             Type originalType;
-            if (valueToConvert == null || valueToConvert == AutomationNull.Value)
+
+            if (IsNull(valueToConvert))
             {
-                valueAsPsObj = null;
                 originalType = typeof(Null);
+                valueAsPsObj = null;
             }
             else
             {

src/System.Management.Automation/engine/runtime/Binding/Binders.cs

@@ -3028,15 +3028,19 @@ private DynamicMetaObject CompareEQ(DynamicMetaObject target,
             if (target.Value == null)
             {
                 return new DynamicMetaObject(
-                    arg.Value == null ? ExpressionCache.BoxedTrue : ExpressionCache.BoxedFalse,
+                    LanguagePrimitives.IsNullLike(arg.Value)
+                        ? ExpressionCache.BoxedTrue
+                        : ExpressionCache.BoxedFalse,
                     target.CombineRestrictions(arg));
             }
 
             var enumerable = PSEnumerableBinder.IsEnumerable(target);
             if (enumerable == null && arg.Value == null)
             {
                 return new DynamicMetaObject(
-                    ExpressionCache.BoxedFalse,
+                    LanguagePrimitives.IsNullLike(target.Value)
+                        ? ExpressionCache.BoxedTrue
+                        : ExpressionCache.BoxedFalse,
                     target.CombineRestrictions(arg));
             }
 
@@ -3051,14 +3055,19 @@ private DynamicMetaObject CompareNE(DynamicMetaObject target,
             if (target.Value == null)
             {
                 return new DynamicMetaObject(
-                    arg.Value == null ? ExpressionCache.BoxedFalse : ExpressionCache.BoxedTrue,
+                    LanguagePrimitives.IsNullLike(arg.Value)
+                        ? ExpressionCache.BoxedFalse
+                        : ExpressionCache.BoxedTrue,
                     target.CombineRestrictions(arg));
             }
 
             var enumerable = PSEnumerableBinder.IsEnumerable(target);
             if (enumerable == null && arg.Value == null)
             {
-                return new DynamicMetaObject(ExpressionCache.BoxedTrue,
+                return new DynamicMetaObject(
+                    LanguagePrimitives.IsNullLike(target.Value)
+                        ? ExpressionCache.BoxedFalse
+                        : ExpressionCache.BoxedTrue,
                     target.CombineRestrictions(arg));
             }