SDSL: infer array size from initializer for static const member arrays

`static const uint info[] = {...};` left the symbol's type as
ArrayType(Size=-1) even though the initializer fixed the count, so
indexing the constant later allocated a Function temp typed as
OpTypeRuntimeArray and then OpStored the OpSpecConstantComposite (of
sized OpTypeArray<N>) into it — SPIR-V validation rejected the type
mismatch (e.g. SinglePassWireframeShader's infoA/infoB lookup tables).

Mirror the inference logic from local DeclareStatement: after compiling
the initializer, swap the unsized member type for the value's inferred
sized type before registering the symbol.

Author: xen2

sources/shaders/Stride.Shaders.Parsers/Parsing/SDSL/AST/ShaderElements.MethodOrMember.cs

@@ -225,6 +225,11 @@ public override void ProcessSymbol(SymbolTable table, SpirvContext context)
 
             // Constant: compile right away
             var constantValue = Value.CompileConstantValue(table, context, memberType);
+            // Infer size for unsized arrays (e.g. `static const uint info[] = {...};`) from
+            // the initializer; otherwise indexing the constant later allocates a temp variable
+            // typed as runtime array, mismatching the OpSpecConstantComposite's sized OpTypeArray.
+            if (memberType is ArrayType { Size: -1 } && Value.ValueType is ArrayType { Size: > 0 } inferred)
+                memberType = inferred;
             context.SetName(constantValue.Id, Name);
             var constant = new Symbol(new(Name, SymbolKind.Constant), memberType, constantValue.Id, OwnerType: table.CurrentShader);
             table.CurrentFrame.Add(Name, constant);

sources/shaders/Stride.Shaders.Tests/RenderingTests.cs

@@ -107,6 +107,27 @@ public void DuplicateCBufferNameSurvivesMixerRename()
         Assert.DoesNotContain("cbuffer Settings_", hlsl2);
     }
 
+    [Fact]
+    public void UnsizedConstArrayInfersSizeForIndexing()
+    {
+        // Regression: `static const uint info[] = {...};` was kept as ArrayType
+        // with Size=-1 even after the initializer fixed the count, so indexing
+        // `info[i]` allocated a Function temp typed as OpTypeRuntimeArray and
+        // then OpStored the OpSpecConstantComposite of OpTypeArray<7> into it —
+        // SPIR-V validation rejects the type mismatch.
+        const string shaderName3 = "CSConstArrayInfer";
+        var shaderMixer3 = new ShaderMixer(new ShaderLoader("./assets/SDSL/ComputeTests"));
+        shaderMixer3.ShaderLoader.LoadExternalBuffer(shaderName3, [], out _, out _, out _);
+
+        var log3 = new Stride.Core.Diagnostics.LoggerResult();
+        Assert.True(shaderMixer3.MergeSDSL(new ShaderClassSource(shaderName3), new ShaderMixer.Options(true), log3, out var bytecode3, out _, out _, out _),
+            string.Join(Environment.NewLine, log3.Messages.Select(m => m.Text)));
+
+        File.WriteAllBytes($"{shaderName3}.spv", bytecode3);
+        var validation = Spv.ValidateFile($"{shaderName3}.spv");
+        Assert.True(validation.IsValid, validation.Output);
+    }
+
     [Fact]
     public void StructuredBufferEmitsStructuredBufferHlsl()
     {

sources/shaders/assets/SDSL/ComputeTests/CSConstArrayInfer.sdsl

@@ -0,0 +1,22 @@
+// PSMain(ExpectedResult=#00000000)
+
+namespace Stride.Shaders.Tests;
+
+// Regression: an unsized const array (size inferred from initializer) used as
+// the source of a dynamic indexing must yield a sized array temp, not a
+// runtime-array temp — otherwise OpStore on the materialization fails SPIR-V
+// validation with "OpStore Pointer's type does not match Object's type".
+shader CSConstArrayInfer
+{
+    static const uint info[] = { 0, 1, 2, 3, 4, 5, 6 };
+
+    stage stream uint3 DispatchThreadId : SV_DispatchThreadID;
+    RWStructuredBuffer<uint> Out;
+
+    [numthreads(1, 1, 1)]
+    void CSMain()
+    {
+        uint idx = streams.DispatchThreadId.x;
+        Out[idx] = info[idx];
+    }
+};