fix: HLSL row_major matrices + GLSL namedExpressions leak (v0.14.1)

* fix(hlsl): row_major matrices, mul() reversal, unique entry points, typed call results

- Add row_major qualifier for matrix-typed struct members and cbuffer
  declarations (fixes WGSL M[i] column access → HLSL row access mismatch
  that caused DX12 MSDF text to be invisible due to w=-378 clipping)
- Reverse mul() arguments for matrix multiply (row_major transposes
  storage, so mul(right, left) matches WGSL left * right semantics)
- Use stage prefix + original name for unique entry point names
  (vs_vs_main, ps_fs_main, ps_fs_main_outline, ps_fs_main_shadow)
- Declare typed local variables for function call results (_crN)
- Map output local variable to _output with output struct type
- Add containsMatrix helper for arrays-of-matrices
- Add TestE2E_MatrixRowMajor, TestE2E_MatrixMulReversed tests
- Update existing tests for row_major assertions

* fix(glsl): clear namedExpressions between functions

GLSL writer shared namedExpressions map across all functions in
a module. When compiling multi-function shaders (e.g., MSDF text),
expression names from earlier functions leaked into later ones.

Example: sampleSD() stored namedExpressions[8]="_fc8", then in
vs_main expression handle 8 (literal 0 for transform[0]) resolved
to "_fc8" instead of "0", producing invalid GLSL:
  uniforms.transform[_fc8]  // undeclared identifier

Fix: reset namedExpressions at start of writeFunction() and
writeEntryPoint(), matching HLSL/MSL backends which already do this.

* refactor(hlsl): reduce writeEntryPointWithIO complexity, update CHANGELOG for v0.14.1

Extract writeReturnSemantic and writeEntryPointLocalVars helpers
to bring cognitive complexity from 32 to under 30 (gocognit limit).
Add CHANGELOG entry for v0.14.1 (HLSL row_major + GLSL namedExpressions fixes).

Author: kolkov

CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.14.1] - 2026-02-21
+
+### Fixed
+
+#### HLSL Backend
+- `row_major` qualifier for matrix struct members in cbuffer/uniform blocks — DX12 `M[i]` column access was returning rows instead of columns, causing transposed transforms and invisible geometry
+- `mul(right, left)` argument reversal for `row_major` matrices — HLSL `mul()` semantics differ from WGSL `*` operator when layout changes
+- Unique entry point names — prevent HLSL duplicate function errors when multiple entry points reference the same function
+- Typed call results — function calls now use correct return type instead of void
+
+#### GLSL Backend
+- Clear `namedExpressions` between function compilations — expression handle names from one WGSL function were leaking into subsequent functions, causing `undeclared identifier` errors in GLES shaders
+
 ## [0.14.0] - 2026-02-21
 
 Major WGSL language coverage expansion: 15/15 Essential reference shaders from Rust naga test suite now compile to valid SPIR-V.

glsl/writer.go

@@ -722,6 +722,7 @@ func (w *Writer) writeFunction(handle ir.FunctionHandle, fn *ir.Function) error
 	w.currentFunction = fn
 	w.currentFuncHandle = handle
 	w.localNames = make(map[uint32]string)
+	w.namedExpressions = make(map[ir.ExpressionHandle]string)
 
 	name := w.names[nameKey{kind: nameKeyFunction, handle1: uint32(handle)}]
 
@@ -782,6 +783,7 @@ func (w *Writer) writeEntryPoint(epIdx int, ep *ir.EntryPoint) error {
 	w.currentFunction = fn
 	w.currentFuncHandle = ep.Function
 	w.localNames = make(map[uint32]string)
+	w.namedExpressions = make(map[ir.ExpressionHandle]string)
 	w.inEntryPoint = true
 	w.entryPointResult = fn.Result
 	w.epStructArgs = make(map[uint32]*epStructInfo)

hlsl/expressions.go

@@ -406,7 +406,7 @@ func (w *Writer) writeUnaryExpression(e ir.ExprUnary) error {
 
 // writeBinaryExpression writes a binary operation.
 //
-//nolint:gocyclo,cyclop // Binary operator mapping requires many cases (19 operators)
+//nolint:gocyclo,cyclop,funlen // Binary operator mapping requires many cases (19 operators + matrix mul)
 func (w *Writer) writeBinaryExpression(e ir.ExprBinary) error {
 	var op string
 	switch e.Op {
@@ -415,6 +415,25 @@ func (w *Writer) writeBinaryExpression(e ir.ExprBinary) error {
 	case ir.BinarySubtract:
 		op = "-"
 	case ir.BinaryMultiply:
+		// When either operand is a matrix, use mul() with reversed args.
+		// HLSL row_major storage transposes the matrix, so mul(right, left)
+		// produces the correct result matching WGSL's left * right semantics.
+		leftType := w.getExpressionTypeInner(e.Left)
+		rightType := w.getExpressionTypeInner(e.Right)
+		_, leftIsMatrix := leftType.(ir.MatrixType)
+		_, rightIsMatrix := rightType.(ir.MatrixType)
+		if leftIsMatrix || rightIsMatrix {
+			w.out.WriteString("mul(")
+			if err := w.writeExpression(e.Right); err != nil {
+				return fmt.Errorf("binary right: %w", err)
+			}
+			w.out.WriteString(", ")
+			if err := w.writeExpression(e.Left); err != nil {
+				return fmt.Errorf("binary left: %w", err)
+			}
+			w.out.WriteString(")")
+			return nil
+		}
 		op = "*"
 	case ir.BinaryDivide:
 		op = "/"
@@ -1050,9 +1069,10 @@ func (w *Writer) writeImageQueryExpression(e ir.ExprImageQuery) error {
 // =============================================================================
 
 // writeCallResultExpression writes a reference to a call result.
+// Normally this is NOT reached because writeCallStatement registers the
+// result in namedExpressions, and writeExpression returns the cached name
+// before dispatching here. This fallback exists for safety.
 func (w *Writer) writeCallResultExpression(e ir.ExprCallResult) error {
-	// The call result is stored in a temporary by the call statement
-	// This references that temporary
 	name := w.names[nameKey{kind: nameKeyFunction, handle1: uint32(e.Function)}]
 	fmt.Fprintf(&w.out, "_%s_result", name)
 	return nil
@@ -1120,8 +1140,6 @@ func (w *Writer) writeExpressionToString(handle ir.ExpressionHandle) (string, er
 }
 
 // getExpressionTypeInner returns just the TypeInner for an expression.
-//
-//nolint:unused // Helper prepared for integration when needed
 func (w *Writer) getExpressionTypeInner(handle ir.ExpressionHandle) ir.TypeInner {
 	typ := w.getExpressionType(handle)
 	if typ != nil {

hlsl/functions.go

@@ -237,21 +237,7 @@ func (w *Writer) writeEntryPointWithIO(epIdx int, ep *ir.EntryPoint) error {
 	// Write function signature
 	w.writeEntryPointSignature(returnType, epName, ep, fn, inputStructName, hasInputStruct)
 
-	// Add return semantic for simple (non-struct) return types.
-	// Fragment shader @location(N) maps to SV_TargetN (not TEXCOORD).
-	if !hasOutputStruct && fn.Result != nil && fn.Result.Binding != nil {
-		var semantic string
-		if ep.Stage == ir.StageFragment {
-			if loc, ok := (*fn.Result.Binding).(ir.LocationBinding); ok {
-				semantic = fmt.Sprintf("SV_Target%d", loc.Location)
-			} else {
-				semantic = w.getSemanticFromBinding(*fn.Result.Binding, 0)
-			}
-		} else {
-			semantic = w.getSemanticFromBinding(*fn.Result.Binding, 0)
-		}
-		fmt.Fprintf(&w.out, " : %s", semantic)
-	}
+	w.writeReturnSemantic(ep, fn, hasOutputStruct)
 
 	w.writeLine(" {")
 	w.pushIndent()
@@ -261,31 +247,14 @@ func (w *Writer) writeEntryPointWithIO(epIdx int, ep *ir.EntryPoint) error {
 		w.writeInputExtraction(ep, fn, structArgs)
 	}
 
-	// Write local variables with optional init expressions
-	for localIdx, local := range fn.LocalVars {
-		localName := w.namer.call(local.Name)
-		w.localNames[uint32(localIdx)] = localName
-		// HLSL arrays: type name[size], not type[size] name
-		localType, arraySuffix := w.getTypeNameWithArraySuffix(local.Type)
-		if local.Init != nil {
-			w.writeIndent()
-			fmt.Fprintf(&w.out, "%s %s%s = ", localType, localName, arraySuffix)
-			if err := w.writeExpression(*local.Init); err != nil {
-				w.popIndent()
-				return fmt.Errorf("entry point local var init: %w", err)
-			}
-			w.out.WriteString(";\n")
-		} else {
-			w.writeLine("%s %s%s;", localType, localName, arraySuffix)
-		}
-	}
-
-	if len(fn.LocalVars) > 0 || hasInputStruct {
-		w.writeLine("")
+	outputLocalMapped, err := w.writeEntryPointLocalVars(fn, hasOutputStruct, outputStructName, hasInputStruct)
+	if err != nil {
+		w.popIndent()
+		return err
 	}
 
-	// Create output struct if needed
-	if hasOutputStruct {
+	// Create output struct if not already mapped from a local variable
+	if hasOutputStruct && !outputLocalMapped {
 		w.writeLine("%s _output;", outputStructName)
 		w.writeLine("")
 	}
@@ -296,7 +265,7 @@ func (w *Writer) writeEntryPointWithIO(epIdx int, ep *ir.EntryPoint) error {
 		return err
 	}
 
-	// Return output struct if needed
+	// Return output struct if needed (fallback for control flow paths without explicit return)
 	if hasOutputStruct {
 		w.writeLine("return _output;")
 	}
@@ -323,6 +292,62 @@ func (w *Writer) writeComputeAttributes(ep *ir.EntryPoint) {
 	w.writeLine("[numthreads(%d, %d, %d)]", x, y, z)
 }
 
+// writeReturnSemantic adds HLSL return semantic for simple (non-struct) return types.
+// Fragment shader @location(N) maps to SV_TargetN (not TEXCOORD).
+func (w *Writer) writeReturnSemantic(ep *ir.EntryPoint, fn *ir.Function, hasOutputStruct bool) {
+	if hasOutputStruct || fn.Result == nil || fn.Result.Binding == nil {
+		return
+	}
+	var semantic string
+	if ep.Stage == ir.StageFragment {
+		if loc, ok := (*fn.Result.Binding).(ir.LocationBinding); ok {
+			semantic = fmt.Sprintf("SV_Target%d", loc.Location)
+		} else {
+			semantic = w.getSemanticFromBinding(*fn.Result.Binding, 0)
+		}
+	} else {
+		semantic = w.getSemanticFromBinding(*fn.Result.Binding, 0)
+	}
+	fmt.Fprintf(&w.out, " : %s", semantic)
+}
+
+// writeEntryPointLocalVars writes local variable declarations for an entry point.
+// When a local variable has the same type as the entry point result, it IS the
+// output variable — declared as _output with the output struct type so that HLSL
+// semantics (SV_Position, TEXCOORD) are attached correctly.
+// Returns whether an output local was mapped to _output.
+func (w *Writer) writeEntryPointLocalVars(fn *ir.Function, hasOutputStruct bool, outputStructName string, hasInputStruct bool) (bool, error) {
+	outputLocalMapped := false
+	for localIdx, local := range fn.LocalVars {
+		localName := w.namer.call(local.Name)
+		localType, arraySuffix := w.getTypeNameWithArraySuffix(local.Type)
+
+		if hasOutputStruct && !outputLocalMapped && fn.Result != nil && local.Type == fn.Result.Type {
+			localName = "_output"
+			localType = outputStructName
+			outputLocalMapped = true
+		}
+
+		w.localNames[uint32(localIdx)] = localName
+
+		if local.Init != nil {
+			w.writeIndent()
+			fmt.Fprintf(&w.out, "%s %s%s = ", localType, localName, arraySuffix)
+			if err := w.writeExpression(*local.Init); err != nil {
+				return false, fmt.Errorf("entry point local var init: %w", err)
+			}
+			w.out.WriteString(";\n")
+		} else {
+			w.writeLine("%s %s%s;", localType, localName, arraySuffix)
+		}
+	}
+
+	if len(fn.LocalVars) > 0 || hasInputStruct {
+		w.writeLine("")
+	}
+	return outputLocalMapped, nil
+}
+
 // writeEntryPointSignature writes the function signature for an entry point.
 func (w *Writer) writeEntryPointSignature(returnType, epName string, ep *ir.EntryPoint, fn *ir.Function, inputStructName string, hasInputStruct bool) {
 	w.writeIndent()