Handle mixed multidimensional/jagged arrays properly (fixes dotnet#2893) (dotnet#2894)

* Generate proper typename for mixed composition arrays

* Generate proper display name for mixed composition arrays

* Add test to check for mixed composition array display name

* Remove trailing whitespace from ArgumentsTests

Author: User0332

src/BenchmarkDotNet/Code/ArrayParam.cs

@@ -9,11 +9,29 @@ namespace BenchmarkDotNet.Code
 {
     internal static class ArrayParam
     {
+        private static (string BaseElementTypeRepr, string InnerDimensions) GetDisplayString(Type arrayType)
+        {
+            var elemType = arrayType.GetElementType();
+
+            if (elemType.IsArray)
+            {
+                var (baseElementTypeRepr, innerDimensions) = GetDisplayString(elemType);
+
+                return (baseElementTypeRepr, $"[{new string(',', arrayType.GetArrayRank() - 1)}]{innerDimensions}");
+            }
+
+            return (elemType.GetDisplayName(), $"[{new string(',', arrayType.GetArrayRank() - 1)}]");
+        }
+
         public static string GetDisplayString(Array array)
         {
             string dimensionRepr = string.Join(", ", Enumerable.Range(0, array.Rank).Select(array.GetLength));
 
-            return $"{array.GetType().GetElementType()?.GetDisplayName()}[{dimensionRepr}]";
+            var (baseElementTypeRepr, innerDimensions) = GetDisplayString(array.GetType());
+
+            innerDimensions = string.Join("", innerDimensions.Split([']'], count: 2).Skip(1));
+
+            return $"{baseElementTypeRepr}[{dimensionRepr}]{innerDimensions}";
         }
     }
 

src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs

@@ -57,7 +57,16 @@ internal static string GetCorrectCSharpTypeName(this Type type, bool includeName
                 return type.Name;
 
             if (type.IsArray)
-                return GetCorrectCSharpTypeName(type.GetElementType()) + "[" + new string(',', type.GetArrayRank() - 1) + "]";
+            {
+                var typeName = GetCorrectCSharpTypeName(type.GetElementType());
+                var parts = typeName.Split(['['], count: 2);
+
+                string repr = parts[0] + '[' + new string(',', type.GetArrayRank() - 1) + ']';
+
+                if (parts.Length == 2) return repr + '[' + parts[1];
+
+                return repr;
+            }
 
             return prefix + string.Join(".", GetNestedTypeNames(type, includeGenericArgumentsNamespace).Reverse());
         }

tests/BenchmarkDotNet.IntegrationTests/ArgumentsTests.cs

@@ -692,6 +692,33 @@ public void AcceptsMultidimensionalArray(int[,] arr)
             }
         }
 
+        [Theory, MemberData(nameof(GetToolchains), DisableDiscoveryEnumeration = true)]
+        public void MultidimensionalAndJaggedArraysCanBeMixed(IToolchain toolchain)
+        {
+            var summary = CanExecute<WithMixedJaggedAndMultidimensionalArrays>(toolchain);
+
+            Assert.Equal(
+                "Int32[0, 0][][,][]",
+                summary.Table.Columns.Where(col => col.Header == "arr").First().Content[0]
+            );
+        }
+
+        public class WithMixedJaggedAndMultidimensionalArrays
+        {
+            public IEnumerable<int[,][][,][]> GetArrays()
+            {
+                yield return new int[,][][,][] { };
+            }
+
+            [Benchmark]
+            [ArgumentsSource(nameof(GetArrays))]
+            public void AcceptsMixedArray(int[,][][,][] arr)
+            {
+                if (arr.Length > 0)
+                    throw new ArgumentException("Incorrect length");
+            }
+        }
+
         [Theory, MemberData(nameof(GetToolchains), DisableDiscoveryEnumeration = true)]
         public void VeryBigIntegersAreSupported(IToolchain toolchain) => CanExecute<WithVeryBigInteger>(toolchain);