Adding a debug view to System.Numerics.Vector<T>

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -514,6 +514,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Vector2.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Vector3.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\Vector4.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\VectorDebugView_1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\VectorMath.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Object.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\ObjectDisposedException.cs" />

src/libraries/System.Private.CoreLib/src/System/Numerics/VectorDebugView_1.cs

@@ -0,0 +1,138 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.Runtime.CompilerServices;
+
+namespace System.Numerics
+{
+    internal readonly struct VectorDebugView<T>
+        where T : struct
+    {
+        private readonly Vector<T> _value;
+
+        public VectorDebugView(Vector<T> value)
+        {
+            _value = value;
+        }
+
+        public byte[] ByteView
+        {
+            get
+            {
+                var items = new byte[Vector<byte>.Count];
+                Unsafe.WriteUnaligned(ref items[0], _value);
+                return items;
+            }
+        }
+
+        public double[] DoubleView
+        {
+            get
+            {
+                var items = new double[Vector<double>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public short[] Int16View
+        {
+            get
+            {
+                var items = new short[Vector<short>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public int[] Int32View
+        {
+            get
+            {
+                var items = new int[Vector<int>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public long[] Int64View
+        {
+            get
+            {
+                var items = new long[Vector<long>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public nint[] NIntView
+        {
+            get
+            {
+                var items = new nint[Vector<nint>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<nint, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public nuint[] NUIntView
+        {
+            get
+            {
+                var items = new nuint[Vector<nuint>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<nuint, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public sbyte[] SByteView
+        {
+            get
+            {
+                var items = new sbyte[Vector<sbyte>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public float[] SingleView
+        {
+            get
+            {
+                var items = new float[Vector<float>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public ushort[] UInt16View
+        {
+            get
+            {
+                var items = new ushort[Vector<ushort>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public uint[] UInt32View
+        {
+            get
+            {
+                var items = new uint[Vector<uint>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+
+        public ulong[] UInt64View
+        {
+            get
+            {
+                var items = new ulong[Vector<ulong>.Count];
+                Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref items[0]), _value);
+                return items;
+            }
+        }
+    }
+}

src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Runtime.CompilerServices;
@@ -30,6 +31,8 @@ namespace System.Numerics
     /// large algorithms. This type is immutable, individual elements cannot be modified.
     /// </summary>
     [Intrinsic]
+    [DebuggerDisplay("{DisplayString,nq}")]
+    [DebuggerTypeProxy(typeof(VectorDebugView<>))]
     public readonly struct Vector<T> : IEquatable<Vector<T>>, IFormattable
         where T : struct
     {
@@ -149,6 +152,23 @@ public static int Count
             }
         }
 
+        internal static bool IsSupported
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (typeof(T) == typeof(byte)) ||
+                   (typeof(T) == typeof(double)) ||
+                   (typeof(T) == typeof(short)) ||
+                   (typeof(T) == typeof(int)) ||
+                   (typeof(T) == typeof(long)) ||
+                   (typeof(T) == typeof(nint)) ||
+                   (typeof(T) == typeof(nuint)) ||
+                   (typeof(T) == typeof(sbyte)) ||
+                   (typeof(T) == typeof(float)) ||
+                   (typeof(T) == typeof(ushort)) ||
+                   (typeof(T) == typeof(uint)) ||
+                   (typeof(T) == typeof(ulong));
+        }
+
         /// <summary>Gets a new <see cref="Vector{T}" /> with all elements initialized to one.</summary>
         /// <exception cref="NotSupportedException">The type of the current instance (<typeparamref name="T" />) is not supported.</exception>
         public static Vector<T> One
@@ -169,6 +189,21 @@ public static Vector<T> Zero
             }
         }
 
+        internal unsafe string DisplayString
+        {
+            get
+            {
+                if (IsSupported)
+                {
+                    return ToString();
+                }
+                else
+                {
+                    return SR.NotSupported_Type;
+                }
+            }
+        }
+
         /// <summary>Gets the element at the specified index.</summary>
         /// <param name="index">The index of the element to get.</param>
         /// <returns>The value of the element at <paramref name="index" />.</returns>

src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs

@@ -39,6 +39,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -600,12 +601,7 @@ internal static void IfNullAndNullsAreIllegalThenThrow<T>(object? value, Excepti
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static void ThrowForUnsupportedNumericsVectorBaseType<T>() where T : struct
         {
-            if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) &&
-                typeof(T) != typeof(short) && typeof(T) != typeof(ushort) &&
-                typeof(T) != typeof(int) && typeof(T) != typeof(uint) &&
-                typeof(T) != typeof(long) && typeof(T) != typeof(ulong) &&
-                typeof(T) != typeof(float) && typeof(T) != typeof(double) &&
-                typeof(T) != typeof(nint) && typeof(T) != typeof(nuint))
+            if (!Vector<T>.IsSupported)
             {
                 ThrowNotSupportedException(ExceptionResource.Arg_TypeNotSupported);
             }