Treat [NullString]::Value as the string type when resolving methods (PowerShell#18080)

Author: daxian-dbw

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

@@ -833,7 +833,7 @@ private static Type GetArgumentType(object argument, bool isByRefParameter)
                 return GetArgumentType(PSObject.Base(psref.Value), isByRefParameter: false);
             }
 
-            return argument.GetType();
+            return GetObjectType(argument, debase: false);
         }
 
         internal static ConversionRank GetArgumentConversionRank(object argument, Type parameterType, bool isByRef, bool allowCastingToByRefLikeType)
@@ -1670,18 +1670,21 @@ private static MethodInformation FindBestMethodImpl(
 
         internal static Type EffectiveArgumentType(object arg)
         {
-            if (arg != null)
+            arg = PSObject.Base(arg);
+            if (arg is null)
             {
-                arg = PSObject.Base(arg);
-                object[] argAsArray = arg as object[];
-                if (argAsArray != null && argAsArray.Length > 0 && PSObject.Base(argAsArray[0]) != null)
+                return typeof(LanguagePrimitives.Null);
+            }
+
+            if (arg is object[] array && array.Length > 0)
+            {
+                Type firstType = GetObjectType(array[0], debase: true);
+                if (firstType is not null)
                 {
-                    Type firstType = PSObject.Base(argAsArray[0]).GetType();
                     bool allSameType = true;
-
-                    for (int j = 1; j < argAsArray.Length; ++j)
+                    for (int j = 1; j < array.Length; ++j)
                     {
-                        if (argAsArray[j] == null || firstType != PSObject.Base(argAsArray[j]).GetType())
+                        if (firstType != GetObjectType(array[j], debase: true))
                         {
                             allSameType = false;
                             break;
@@ -1693,13 +1696,19 @@ internal static Type EffectiveArgumentType(object arg)
                         return firstType.MakeArrayType();
                     }
                 }
-
-                return arg.GetType();
             }
-            else
+
+            return GetObjectType(arg, debase: false);
+        }
+
+        internal static Type GetObjectType(object obj, bool debase)
+        {
+            if (debase)
             {
-                return typeof(LanguagePrimitives.Null);
+                obj = PSObject.Base(obj);
             }
+
+            return obj == NullString.Value ? typeof(string) : obj?.GetType();
         }
 
         internal static void SetReferences(object[] arguments, MethodInformation methodInformation, object[] originalArguments)

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

@@ -7349,11 +7349,15 @@ internal static bool IsHomogenousArray<T>(object[] args)
                 return false;
             }
 
-            return args.All(element =>
-                            {
-                                var obj = PSObject.Base(element);
-                                return obj != null && obj.GetType().Equals(typeof(T));
-                            });
+            foreach (object element in args)
+            {
+                if (Adapter.GetObjectType(element, debase: true) != typeof(T))
+                {
+                    return false;
+                }
+            }
+
+            return true;
         }
 
         internal static bool IsHeterogeneousArray(object[] args)
@@ -7381,11 +7385,15 @@ internal static bool IsHeterogeneousArray(object[] args)
                 return true;
             }
 
-            return args.Skip(1).Any(element =>
-                                    {
-                                        var obj = PSObject.Base(element);
-                                        return obj == null || !firstType.Equals(obj.GetType());
-                                    });
+            for (int i = 1; i < args.Length; i++)
+            {
+                if (Adapter.GetObjectType(args[i], debase: true) != firstType)
+                {
+                    return true;
+                }
+            }
+
+            return false;
         }
 
         internal static object InvokeAdaptedMember(object obj, string methodName, object[] args)

test/powershell/Language/Scripting/Scripting.Followup.Tests.ps1

@@ -90,4 +90,42 @@ Describe "Scripting.Followup.Tests" -Tags "CI" {
 
         TestFunc2 | Should -Be @("1", "2")
     }
+
+    It "'[NullString]::Value' should be treated as string type when resolving .NET method" {
+        $testType = 'NullStringTest' -as [type]
+        if (-not $testType) {
+            Add-Type -TypeDefinition @'
+using System;
+public class NullStringTest {
+    public static string Test(bool argument)
+    {
+        return "bool";
+    }
+
+    public static string Test(string argument)
+    {
+        return "string";
+    }
+
+    public static string Get<T>(T argument)
+    {
+        string ret = typeof(T).FullName;
+        if (argument is string[] array)
+        {
+            if (array[1] == null)
+            {
+                return ret + "; 2nd element is NULL";
+            }
+        }
+
+        return ret;
+    }
+}
+'@
+        }
+
+        [NullStringTest]::Test([NullString]::Value) | Should -BeExactly 'string'
+        [NullStringTest]::Get([NullString]::Value) | Should -BeExactly 'System.String'
+        [NullStringTest]::Get(@('foo', [NullString]::Value, 'bar')) | Should -BeExactly 'System.String[]; 2nd element is NULL'
+    }
 }