cleanup(where, asanyarray): remove dead code and trim noisy comments

Code review caught dead code paths and over-narrative comments. Net change is
-293/+19 across three files.

ILKernelGenerator.Where.cs (-249 lines):
- Delete `GetNPTypeCode<T>` (use shared InfoOf<T>.NPTypeCode instead).
- Delete `GetMaskCreationMethod256/128` and the entire 200-line
  `Static Mask Creation Methods (fallback)` region (CreateMaskV256_*Byte and
  CreateMaskV128_*Byte). They were never called -- the inline IL emitter at
  EmitInlineMaskCreationV256/V128 handles the mask creation directly via the
  cached MethodInfo lookups. The static helpers existed as an early prototype
  fallback path that became unreachable.
- Delete `_v256ZeroULong` field with the meaningless `IsStatic ? null! : null!`
  tautology (only `_v256GetZeroULong` is used).

np.where.cs (+2 lines):
- Add `default: throw NotSupportedException(...)` to `WhereKernelDispatch`
  switch. The kernel path is currently only reached for the 12 supported
  NPTypeCodes, but the missing default would silently fall through and return
  an uninitialized result if a new NPTypeCode were ever added without updating
  this switch. The iterator-path switch (line 142) already has this guard.

np.asanyarray.cs (-43/+18 net):
- Cap `stackalloc NPTypeCode[span.Length]` at 12 (max possible unique
  NPTypeCodes given the seenMask deduplication). The previous unbounded
  stackalloc could blow the stack for very large user lists.
- Remove dead `hasDecimal` variable (set but never read; the early-exit
  for decimal returns immediately on first hit).
- Trim narrative/microbenchmark comments per CLAUDE.md guidance:
  removed "Optimized: ...3-7x faster", "optimization #4", "~4x faster than
  always using Convert", "Pre-sized list (optimization: ...)", and a handful
  of WHAT-the-code-does comments that restated obvious switch arms.
- Tighten Tuple/Enumerator helpers (collapse trivial if/else into ternary).

Verified: 178 np.where + np.asanyarray tests still pass on net8.0 + net10.0.

Author: Nucs

src/NumSharp.Core/APIs/np.where.cs

@@ -209,6 +209,8 @@ private static unsafe void WhereKernelDispatch(NDArray cond, NDArray x, NDArray
                 case NPTypeCode.Decimal:
                     ILKernelGenerator.WhereExecute(condPtr, (decimal*)x.Address, (decimal*)y.Address, (decimal*)result.Address, count);
                     break;
+                default:
+                    throw new NotSupportedException($"Type {outType} not supported for np.where");
             }
         }
     }

src/NumSharp.Core/Backends/Kernels/ILKernelGenerator.Where.cs

@@ -5,6 +5,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using NumSharp.Utilities;
 
 // =============================================================================
 // ILKernelGenerator.Where - IL-generated np.where(condition, x, y) kernels
@@ -400,7 +401,7 @@ private static void EmitWhereV128BodyWithOffset<T>(ILGenerator il, LocalBuilder
         private static void EmitWhereScalarElement<T>(ILGenerator il, LocalBuilder locI) where T : unmanaged
         {
             long elementSize = Unsafe.SizeOf<T>();
-            var typeCode = GetNPTypeCode<T>();
+            var typeCode = InfoOf<T>.NPTypeCode;
 
             // result[i] = cond[i] ? x[i] : y[i]
             var lblFalse = il.DefineLabel();
@@ -449,51 +450,6 @@ private static void EmitWhereScalarElement<T>(ILGenerator il, LocalBuilder locI)
             EmitStoreIndirect(il, typeCode);
         }
 
-        private static NPTypeCode GetNPTypeCode<T>() where T : unmanaged
-        {
-            if (typeof(T) == typeof(bool)) return NPTypeCode.Boolean;
-            if (typeof(T) == typeof(byte)) return NPTypeCode.Byte;
-            if (typeof(T) == typeof(short)) return NPTypeCode.Int16;
-            if (typeof(T) == typeof(ushort)) return NPTypeCode.UInt16;
-            if (typeof(T) == typeof(int)) return NPTypeCode.Int32;
-            if (typeof(T) == typeof(uint)) return NPTypeCode.UInt32;
-            if (typeof(T) == typeof(long)) return NPTypeCode.Int64;
-            if (typeof(T) == typeof(ulong)) return NPTypeCode.UInt64;
-            if (typeof(T) == typeof(char)) return NPTypeCode.Char;
-            if (typeof(T) == typeof(float)) return NPTypeCode.Single;
-            if (typeof(T) == typeof(double)) return NPTypeCode.Double;
-            if (typeof(T) == typeof(decimal)) return NPTypeCode.Decimal;
-            return NPTypeCode.Empty;
-        }
-
-        #endregion
-
-        #region Mask Creation Methods
-
-        private static MethodInfo GetMaskCreationMethod256(int elementSize)
-        {
-            return elementSize switch
-            {
-                1 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV256_1Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                2 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV256_2Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                4 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV256_4Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                8 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV256_8Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                _ => throw new NotSupportedException($"Element size {elementSize} not supported for SIMD where")
-            };
-        }
-
-        private static MethodInfo GetMaskCreationMethod128(int elementSize)
-        {
-            return elementSize switch
-            {
-                1 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV128_1Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                2 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV128_2Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                4 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV128_4Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                8 => typeof(ILKernelGenerator).GetMethod(nameof(CreateMaskV128_8Byte), BindingFlags.NonPublic | BindingFlags.Static)!,
-                _ => throw new NotSupportedException($"Element size {elementSize} not supported for SIMD where")
-            };
-        }
-
         #endregion
 
         #region Inline Mask IL Emission
@@ -560,8 +516,6 @@ private static MethodInfo GetMaskCreationMethod128(int elementSize)
         private static readonly MethodInfo _v128GreaterThanByte = Array.Find(typeof(Vector128).GetMethods(),
             m => m.Name == "GreaterThan" && m.IsGenericMethodDefinition)!.MakeGenericMethod(typeof(byte));
 
-        private static readonly FieldInfo _v256ZeroULong = typeof(Vector256<ulong>).GetProperty("Zero")!.GetMethod!.IsStatic
-            ? null! : null!; // Use GetMethod call instead
         private static readonly MethodInfo _v256GetZeroULong = typeof(Vector256<ulong>).GetProperty("Zero")!.GetMethod!;
         private static readonly MethodInfo _v256GetZeroUInt = typeof(Vector256<uint>).GetProperty("Zero")!.GetMethod!;
         private static readonly MethodInfo _v256GetZeroUShort = typeof(Vector256<ushort>).GetProperty("Zero")!.GetMethod!;
@@ -716,205 +670,6 @@ private static void EmitInlineMaskCreationV128(ILGenerator il, int elementSize)
 
         #endregion
 
-        #region Static Mask Creation Methods (fallback)
-
-        /// <summary>
-        /// Create V256 mask from 32 bools for 1-byte elements.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector256<byte> CreateMaskV256_1Byte(byte* bools)
-        {
-            var vec = Vector256.Load(bools);
-            var zero = Vector256<byte>.Zero;
-            var isZero = Vector256.Equals(vec, zero);
-            return Vector256.OnesComplement(isZero);
-        }
-
-        /// <summary>
-        /// Create V256 mask from 16 bools for 2-byte elements.
-        /// Uses AVX2 vpmovzxbw instruction for single-instruction expansion.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector256<ushort> CreateMaskV256_2Byte(byte* bools)
-        {
-            if (Avx2.IsSupported)
-            {
-                // Load 16 bytes into Vector128, zero-extend each byte to 16-bit
-                // vpmovzxbw: byte -> word (16 bytes -> 16 words)
-                var bytes128 = Vector128.Load(bools);
-                var expanded = Avx2.ConvertToVector256Int16(bytes128).AsUInt16();
-                // Compare with zero: non-zero becomes 0xFFFF, zero stays 0
-                return Vector256.GreaterThan(expanded, Vector256<ushort>.Zero);
-            }
-
-            // Scalar fallback for non-AVX2 systems
-            return Vector256.Create(
-                bools[0] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[1] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[2] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[3] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[4] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[5] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[6] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[7] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[8] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[9] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[10] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[11] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[12] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[13] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[14] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[15] != 0 ? (ushort)0xFFFF : (ushort)0
-            );
-        }
-
-        /// <summary>
-        /// Create V256 mask from 8 bools for 4-byte elements.
-        /// Uses AVX2 vpmovzxbd instruction for single-instruction expansion.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector256<uint> CreateMaskV256_4Byte(byte* bools)
-        {
-            if (Avx2.IsSupported)
-            {
-                // Load 8 bytes into low bytes of Vector128, zero-extend each byte to 32-bit
-                // vpmovzxbd: byte -> dword (8 bytes -> 8 dwords)
-                var bytes128 = Vector128.CreateScalar(*(ulong*)bools).AsByte();
-                var expanded = Avx2.ConvertToVector256Int32(bytes128).AsUInt32();
-                // Compare with zero: non-zero becomes 0xFFFF..., zero stays 0
-                return Vector256.GreaterThan(expanded, Vector256<uint>.Zero);
-            }
-
-            // Scalar fallback for non-AVX2 systems
-            return Vector256.Create(
-                bools[0] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[1] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[2] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[3] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[4] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[5] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[6] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[7] != 0 ? 0xFFFFFFFFu : 0u
-            );
-        }
-
-        /// <summary>
-        /// Create V256 mask from 4 bools for 8-byte elements.
-        /// Uses AVX2 vpmovzxbq instruction for single-instruction expansion.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector256<ulong> CreateMaskV256_8Byte(byte* bools)
-        {
-            if (Avx2.IsSupported)
-            {
-                // Load 4 bytes into low bytes of Vector128, zero-extend each byte to 64-bit
-                // vpmovzxbq: byte -> qword (4 bytes -> 4 qwords)
-                var bytes128 = Vector128.CreateScalar(*(uint*)bools).AsByte();
-                var expanded = Avx2.ConvertToVector256Int64(bytes128).AsUInt64();
-                // Compare with zero: non-zero becomes 0xFFFF..., zero stays 0
-                return Vector256.GreaterThan(expanded, Vector256<ulong>.Zero);
-            }
-
-            // Scalar fallback for non-AVX2 systems
-            return Vector256.Create(
-                bools[0] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
-                bools[1] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
-                bools[2] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
-                bools[3] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul
-            );
-        }
-
-        /// <summary>
-        /// Create V128 mask from 16 bools for 1-byte elements.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector128<byte> CreateMaskV128_1Byte(byte* bools)
-        {
-            var vec = Vector128.Load(bools);
-            var zero = Vector128<byte>.Zero;
-            var isZero = Vector128.Equals(vec, zero);
-            return Vector128.OnesComplement(isZero);
-        }
-
-        /// <summary>
-        /// Create V128 mask from 8 bools for 2-byte elements.
-        /// Uses SSE4.1 pmovzxbw instruction for efficient expansion.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector128<ushort> CreateMaskV128_2Byte(byte* bools)
-        {
-            if (Sse41.IsSupported)
-            {
-                // Load 8 bytes, zero-extend each to 16-bit
-                // pmovzxbw: byte -> word (8 bytes -> 8 words)
-                var bytes128 = Vector128.CreateScalar(*(ulong*)bools).AsByte();
-                var expanded = Sse41.ConvertToVector128Int16(bytes128).AsUInt16();
-                return Vector128.GreaterThan(expanded, Vector128<ushort>.Zero);
-            }
-
-            // Scalar fallback
-            return Vector128.Create(
-                bools[0] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[1] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[2] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[3] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[4] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[5] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[6] != 0 ? (ushort)0xFFFF : (ushort)0,
-                bools[7] != 0 ? (ushort)0xFFFF : (ushort)0
-            );
-        }
-
-        /// <summary>
-        /// Create V128 mask from 4 bools for 4-byte elements.
-        /// Uses SSE4.1 pmovzxbd instruction for efficient expansion.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector128<uint> CreateMaskV128_4Byte(byte* bools)
-        {
-            if (Sse41.IsSupported)
-            {
-                // Load 4 bytes, zero-extend each to 32-bit
-                // pmovzxbd: byte -> dword (4 bytes -> 4 dwords)
-                var bytes128 = Vector128.CreateScalar(*(uint*)bools).AsByte();
-                var expanded = Sse41.ConvertToVector128Int32(bytes128).AsUInt32();
-                return Vector128.GreaterThan(expanded, Vector128<uint>.Zero);
-            }
-
-            // Scalar fallback
-            return Vector128.Create(
-                bools[0] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[1] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[2] != 0 ? 0xFFFFFFFFu : 0u,
-                bools[3] != 0 ? 0xFFFFFFFFu : 0u
-            );
-        }
-
-        /// <summary>
-        /// Create V128 mask from 2 bools for 8-byte elements.
-        /// Uses SSE4.1 pmovzxbq instruction for efficient expansion.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector128<ulong> CreateMaskV128_8Byte(byte* bools)
-        {
-            if (Sse41.IsSupported)
-            {
-                // Load 2 bytes, zero-extend each to 64-bit
-                // pmovzxbq: byte -> qword (2 bytes -> 2 qwords)
-                var bytes128 = Vector128.CreateScalar(*(ushort*)bools).AsByte();
-                var expanded = Sse41.ConvertToVector128Int64(bytes128).AsUInt64();
-                return Vector128.GreaterThan(expanded, Vector128<ulong>.Zero);
-            }
-
-            // Scalar fallback
-            return Vector128.Create(
-                bools[0] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul,
-                bools[1] != 0 ? 0xFFFFFFFFFFFFFFFFul : 0ul
-            );
-        }
-
-        #endregion
-
         #region Scalar Fallback
 
         /// <summary>