---
generated: true
model: claude-opus-4-7
generated_at: 2026-05-22T00:00:00+00:00
source_commit: 6e923e2c0fe3cae4e7cf40e25a96569df5b9f009
watched_paths_digest: 05b1016228f8c0bbf2fd6e6ea6d165c4d173a37c116aea0c0eccdb47c10abf97
source_doc: docs/generated/design/ast-reference/types.md
source_doc_digest: 7007cb8ec84defc795a9f755431fcd600ec3df44f2f392d04896c57ec9ce17b9
warning: "Auto-generated. May drift from source. Do not edit by hand."
---

# Tests for ast-reference/types

## Intent
Tests verify the documented user-observable roles of the concrete
`Type` subclasses enumerated in
[`docs/generated/design/ast-reference/types.md`](../../../design/ast-reference/types.md):
the general-purpose pseudotypes (`ErrorType`, `OverloadGroupType`,
`InitializerListType`), the `DeclRefType` family and its arithmetic
descendants (`BasicExpressionType`, `VectorExpressionType`,
`MatrixExpressionType`), the aggregate / collection family
(`ArrayExpressionType`, `TupleType`, `OptionalType`), the
pointer / parameter-passing types (`PtrType`, `BorrowInParamType`,
`OutParamType`, `BorrowInOutParamType`), the resource / texture /
sampler family (`TextureType`, `SamplerStateType`), the buffer family
(`HLSLStructuredBufferType`, `HLSLRWStructuredBufferType`,
`HLSLByteAddressBufferType`, `HLSLRWByteAddressBufferType`), the
parameter-group / constant-buffer family (`ConstantBufferType`,
`ParameterBlockType`), the `FuncType` leaf, the `AndType` conjunction,
the `ThisType` of an interface, the `ModifiedType` (e.g. `const T`),
the `NullPtrType` / `NoneType` singleton literals, and the
`StringType`.

The doc is fundamentally about the **internal AST shape** of these
type classes; the user-observable surface is what type-resolution
(positive) or type-mismatch diagnostics (negative) make visible. Each
test picks one type class, writes the smallest Slang program that
exercises its documented role, and verifies the documented behavior
through an interpreter print or a diagnostic match. INTERPRET is the
primary directive; one multi-target SIMPLE test
(`rwstructuredbuffertype-multi-target.slang`) is included as the
canonical per-target lowering observation for the buffer family.

Internal AST shape claims (which C++ class a checker allocated for a
type, which operand index holds the element type, whether two
identical types share the same `Val*`, the abstract intermediates in
the family hierarchy, synthesized-only types, GPU-only / autodiff-only
type families, pack / variadic types, data-layout marker types) are
recorded under `## Untested claims` because they are unobservable through
any allowed `slang-test` directive.


## Functional coverage
| Claim | Intent | Anchor | Tests |
| --- | --- | --- | --- |
| A TupleType holds a heterogeneous member-type list; the i-th element is reachable as ._i and has the i-th declared type. | functional | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`tupletype-named-fields.slang`](tupletype-named-fields.slang) |
| A TupleType with four heterogeneous element types (half, float, double, int) preserves each position's declared type. | expansion | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`tuple-mixed-precision.slang`](tuple-mixed-precision.slang) |
| An ArrayExpressionType carries an element-type and an element-count; each of the N elements is independently readable and writable. | functional | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`arraytype-sized-elements.slang`](arraytype-sized-elements.slang) |
| An OptionalType<T> distinguishes a wrapped value from no-value; .hasValue and .value expose the state. | functional | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`optionaltype-value-hasvalue.slang`](optionaltype-value-hasvalue.slang) |
| ArrayExpressionType at the smallest element-count (N=1) is still a valid sized array; the single element is independently addressable. | boundary | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`arraytype-single-element.slang`](arraytype-single-element.slang) |
| ArrayExpressionType nests: int[2][3] is an array-of-arrays whose element-type is itself an ArrayExpressionType. | boundary | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`arraytype-multi-dim-2x3.slang`](arraytype-multi-dim-2x3.slang) |
| ArrayExpressionType scales beyond the small smoke-test sizes; an int[16] correctly holds 16 independent elements and the bookends are observable. | stress | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`arraytype-stress-16-elements.slang`](arraytype-stress-16-elements.slang) |
| ArrayExpressionType with a double2 element type carries double-vector elements; the array is indexable per element. | expansion | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`array-of-double2.slang`](array-of-double2.slang) |
| ArrayExpressionType with a half3 element type stores half-vector elements addressable per array index. | expansion | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`array-of-half3.slang`](array-of-half3.slang) |
| OptionalType nests: an Optional<Optional<int>> distinguishes outer-none, inner-none, and inner-has-value cases independently. | stress | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`optionaltype-nested-stress.slang`](optionaltype-nested-stress.slang) |
| OptionalType<T> wraps a bool; the wrapped truthiness is recoverable via .value, distinct from the no-value sentinel .hasValue=false. | boundary | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`optionaltype-optional-of-bool.slang`](optionaltype-optional-of-bool.slang) |
| OptionalType<T> wraps a numeric type T (here float); .hasValue is true for a wrapped value and .value yields it back unchanged. | boundary | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`optionaltype-optional-of-float.slang`](optionaltype-optional-of-float.slang) |
| OptionalType<double2> wraps a vector element type; .hasValue is true for a wrapped vector value and .value yields it back unchanged. | expansion | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`optional-double2.slang`](optional-double2.slang) |
| OptionalType<half3> wraps a half-vector; the wrapped value is observable through .value and .hasValue is true. | expansion | [#aggregate-collection-types](../../../design/ast-reference/types.md#aggregate-collection-types) | [`optional-half3.slang`](optional-half3.slang) |
| An AndType `IA & IB` requires conformance to both interfaces; a type that conforms to both has both interface methods dispatched on it. | functional | [#andtype](../../../design/ast-reference/types.md#andtype) | [`andtype-conjunction-dispatch.slang`](andtype-conjunction-dispatch.slang) |
| An AndType `IA & IB` requires conformance to both interfaces; a type that conforms to only one fails the conjunction and the call is rejected. | negative | [#andtype](../../../design/ast-reference/types.md#andtype) | [`andtype-missing-conformance-rejected.slang`](andtype-missing-conformance-rejected.slang) |
| AndType extends to more than two conjuncts; an `IA & IB & IC` constraint dispatches methods from all three interfaces on a conforming value. | stress | [#andtype](../../../design/ast-reference/types.md#andtype) | [`andtype-three-way-conjunction.slang`](andtype-three-way-conjunction.slang) |
| A MatrixExpressionType is parameterised by element-type, row count, and column count; a floatRxC value's R*C elements are independently readable via [row][col] indexing. | functional | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`matrixtype-row-col.slang`](matrixtype-row-col.slang) |
| A MatrixExpressionType<float, 2, 3> cannot be implicitly assigned to a MatrixExpressionType<float, 3, 2>; the (rows, cols) operands distinguish the two types. | negative | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat-rectangular-shape-mismatch-rejected.slang`](mat-rectangular-shape-mismatch-rejected.slang) |
| A VectorExpressionType is parameterised by element-type and count; a floatN value's N components are independently readable. | functional | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vectortype-components.slang`](vectortype-components.slang) |
| A VectorExpressionType<float, 2> cannot be implicitly assigned to a VectorExpressionType<float, 3> binding; the dim mismatch is diagnosed. | negative | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-vec3-implicit-rejected.slang`](vec2-vec3-implicit-rejected.slang) |
| A decimal literal that exceeds the largest 64-bit integer type produces a documented "integer literal is too large" diagnostic at the BasicExpressionType binding site. | negative | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-literal-too-large-for-uint64.slang`](basictype-literal-too-large-for-uint64.slang) |
| A float2 can be extended to a float3 via the explicit constructor float3(v2, w); element-type is preserved and the new lane carries the supplied scalar. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-to-vec3-extension.slang`](vec2-to-vec3-extension.slang) |
| A float3 can be projected to a float2 via the .xy swizzle; the dimension N reduces from 3 to 2 with element-type preserved. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-to-vec2-truncation.slang`](vec3-to-vec2-truncation.slang) |
| BasicExpressionType for float carries the documented IEEE-754 extremes; +0.0/-0.0 compare equal, +/-inf are reachable by 1/0, NaN compares unequal to itself. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-float-extremes.slang`](basictype-float-extremes.slang) |
| BasicExpressionType for half (16-bit float) carries scalar arithmetic; small fractional values are representable and survive evaluation. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-half-arithmetic.slang`](basictype-half-arithmetic.slang) |
| BasicExpressionType for int holds the full 32-bit signed range; MIN (-2147483648) and MAX (2147483647) round-trip without distortion. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-int-min-max.slang`](basictype-int-min-max.slang) |
| BasicExpressionType for int8_t carries its scalar built-in across the full [-128, 127] range; MIN and MAX literals round-trip through the type. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-int8-min-max.slang`](basictype-int8-min-max.slang) |
| BasicExpressionType for uint at MAX (0xFFFFFFFF) + 1 wraps to 0 per unsigned-wrap semantics. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-uint-wrap-overflow.slang`](basictype-uint-wrap-overflow.slang) |
| BasicExpressionType for uint8_t spans [0, 255]; the lower-edge 0 and upper-edge 255 both round-trip through the scalar. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-uint8-zero-and-max.slang`](basictype-uint8-zero-and-max.slang) |
| Each BasicExpressionType (int, uint, float, bool) carries the value of its scalar built-in; the value flows through evaluation as that type. | functional | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`basictype-scalars.slang`](basictype-scalars.slang) |
| Element-type widening conversion at the vector boundary: a VectorExpressionType<int, 3> converts to VectorExpressionType<float, 3> via explicit construction. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-int-to-float-conversion.slang`](vec3-int-to-float-conversion.slang) |
| MatrixExpressionType at the smallest standard square dim (2x2) holds 2*2=4 elements addressable via [r][c]. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`matrixtype-2x2-square.slang`](matrixtype-2x2-square.slang) |
| MatrixExpressionType at the standard upper-end square dim (4x4) holds 16 elements; an element written at the far corner [3][3] is independently readable. | stress | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`matrixtype-4x4-square-stress.slang`](matrixtype-4x4-square-stress.slang) |
| MatrixExpressionType carries independent row and column counts; a 3-row by 2-column matrix has the documented rows*cols=6 elements addressable. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`matrixtype-3x2-rectangular.slang`](matrixtype-3x2-rectangular.slang) |
| MatrixExpressionType<double, 2, 3>: rectangular shape with double element type; cells round-trip via int(...) widening. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat2x3-double-construction.slang`](mat2x3-double-construction.slang) |
| MatrixExpressionType<double, 3, 3>: square shape with double element type; diagonal cells are independently readable. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat3x3-double-square.slang`](mat3x3-double-square.slang) |
| MatrixExpressionType<float, 2, 3>: 2 rows by 3 columns, 6 elements addressable as [r][c]. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat2x3-float-construction.slang`](mat2x3-float-construction.slang) |
| MatrixExpressionType<float, 2, 4>: 2 rows by 4 columns, 8 elements addressable via [r][c]. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat2x4-float-construction.slang`](mat2x4-float-construction.slang) |
| MatrixExpressionType<float, 2, 4>: elementwise add of two 2x4 matrices yields elementwise sums per cell. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat2x4-add-arithmetic.slang`](mat2x4-add-arithmetic.slang) |
| MatrixExpressionType<float, 3, 4>: 3 rows by 4 columns; far corner [2][3] is independently addressable after a loop fill. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat3x4-float-arithmetic.slang`](mat3x4-float-arithmetic.slang) |
| MatrixExpressionType<float, 4, 2>: 4 rows by 2 columns, 8 elements addressable via [r][c]. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat4x2-float-construction.slang`](mat4x2-float-construction.slang) |
| MatrixExpressionType<float, 4, 3>: 4 rows by 3 columns, 12 elements addressable via [r][c]. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat4x3-float-construction.slang`](mat4x3-float-construction.slang) |
| MatrixExpressionType<half, 3, 3> survives type-checking and lowers to a half matrix type on the HLSL backend. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat3x3-half-hlsl-emit.slang`](mat3x3-half-hlsl-emit.slang) |
| MatrixExpressionType<int, 2, 4>: rectangular shape with integer element type; each cell addressable. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat2x4-int-construction.slang`](mat2x4-int-construction.slang) |
| MatrixExpressionType<int, 4, 4>: square shape with int element type; 16 lanes addressable. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`mat4x4-int-square.slang`](mat4x4-int-square.slang) |
| VectorExpressionType at the largest standard dimension (N=4) supports a full-length swizzle (.wzyx) that permutes all components. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vectortype-vec4-full-swizzle.slang`](vectortype-vec4-full-swizzle.slang) |
| VectorExpressionType at the smallest documented vector dimension (N=2) carries two independently-addressable components. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vectortype-vec2-smallest.slang`](vectortype-vec2-smallest.slang) |
| VectorExpressionType supports element-type conversion via explicit construction from a vector with a different element type; the resulting components have the target's element type. | boundary | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vectortype-mixed-arithmetic.slang`](vectortype-mixed-arithmetic.slang) |
| VectorExpressionType<bool, 2>: two bool lanes are independently addressable; per-component values are observable. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-bool-logical.slang`](vec2-bool-logical.slang) |
| VectorExpressionType<bool, 3>: three bool lanes are independently addressable. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-bool-construction.slang`](vec3-bool-construction.slang) |
| VectorExpressionType<double, 2> instantiation; double2 elementwise multiplication yields elementwise products. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-double-arithmetic.slang`](vec2-double-arithmetic.slang) |
| VectorExpressionType<double, 2>: +0.0lf and -0.0lf compare numerically equal at the lane level. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-double-zero-and-negzero.slang`](vec2-double-zero-and-negzero.slang) |
| VectorExpressionType<double, 3> instantiation; double3 elementwise add survives evaluation across three components. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-double-arithmetic.slang`](vec3-double-arithmetic.slang) |
| VectorExpressionType<double, 4> at the large dim N=4 carries four addressable double components. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-double-construction.slang`](vec4-double-construction.slang) |
| VectorExpressionType<double, 4> survives lane construction with extreme magnitudes; a comparison >1e30 holds per-lane. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-double-extremes.slang`](vec4-double-extremes.slang) |
| VectorExpressionType<float, 3> can hold +inf and NaN per lane; isnan/isinf detect them per component. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-float-inf-nan.slang`](vec3-float-inf-nan.slang) |
| VectorExpressionType<half, 2> is a valid vector instantiation; elementwise add of two half2 values yields the documented elementwise sum. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-half-arithmetic.slang`](vec2-half-arithmetic.slang) |
| VectorExpressionType<half, 3> instantiation: three half components are independently addressable and elementwise add works. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-half-arithmetic.slang`](vec3-half-arithmetic.slang) |
| VectorExpressionType<half, 3> with +0.0 and -0.0 lanes: both compare numerically equal to 0 yet have distinct sign bits. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-half-zero-and-negzero.slang`](vec3-half-zero-and-negzero.slang) |
| VectorExpressionType<half, 4> at the largest standard dim N=4 carries four addressable half components. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-half-construction.slang`](vec4-half-construction.slang) |
| VectorExpressionType<int, 3>: three lanes hold int MIN and MAX endpoints; both round-trip through the per-lane storage. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-int-min-max.slang`](vec3-int-min-max.slang) |
| VectorExpressionType<int16_t, 3>: three int16_t lanes survive arithmetic across the documented signed 16-bit range. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-int16-arithmetic.slang`](vec3-int16-arithmetic.slang) |
| VectorExpressionType<int64_t, 2>: two int64_t lanes carry a 64-bit-range signed value at N=2. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-int64-arithmetic.slang`](vec2-int64-arithmetic.slang) |
| VectorExpressionType<int8_t, 2> instantiation; the documented int8_t MIN (-128) and MAX (127) survive in vector components. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec2-int8-construction.slang`](vec2-int8-construction.slang) |
| VectorExpressionType<int8_t, 4>: four int8_t lanes carry the documented signed [-128, 127] range; both edges survive per-lane. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-int8-min.slang`](vec4-int8-min.slang) |
| VectorExpressionType<uint, 4>: lanes hold the full 32-bit unsigned range [0, 0xFFFFFFFF]; both edges survive per-lane. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-uint-zero-and-max.slang`](vec4-uint-zero-and-max.slang) |
| VectorExpressionType<uint16_t, 4>: four uint16_t lanes carry the documented unsigned 16-bit range. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-uint16-construction.slang`](vec4-uint16-construction.slang) |
| VectorExpressionType<uint64_t, 3>: three unsigned 64-bit lanes survive add into a positive scalar. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-uint64-arithmetic.slang`](vec3-uint64-arithmetic.slang) |
| VectorExpressionType<uint8_t, 3> instantiation; the documented uint8_t range [0, 255] is carried across three lanes. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-uint8-construction.slang`](vec3-uint8-construction.slang) |
| VectorExpressionType<uint8_t, 3>: scalar lane addition of uint8_t MAX (255) and 1 wraps to 0 per documented unsigned-wrap semantics. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec3-uint8-wrap-overflow.slang`](vec3-uint8-wrap-overflow.slang) |
| VectorExpressionType<uint8_t, 4> at the large dim N=4 carries four uint8_t lanes spanning the documented range. | expansion | [#basicexpressiontype-vectorexpressiontype-matrixexpressiontype](../../../design/ast-reference/types.md#basicexpressiontype-vectorexpressiontype-matrixexpressiontype) | [`vec4-uint8-construction.slang`](vec4-uint8-construction.slang) |
| An HLSLByteAddressBufferType uniform reaches the HLSL backend as `ByteAddressBuffer` and `RWByteAddressBuffer`. | functional | [#buffer-types](../../../design/ast-reference/types.md#buffer-types) | [`byteaddressbuffertype-hlsl-emit.slang`](byteaddressbuffertype-hlsl-emit.slang) |
| An HLSLRWStructuredBufferType uniform reaches every text-emit backend; HLSL renders it as `RWStructuredBuffer`, GLSL as a `buffer` block, and CUDA emits a global of the buffer name. | functional | [#buffer-types](../../../design/ast-reference/types.md#buffer-types) | [`rwstructuredbuffertype-multi-target.slang`](rwstructuredbuffertype-multi-target.slang) |
| An HLSLStructuredBufferType (read-only) is distinct from its RW variant; the HLSL emit renders it as `StructuredBuffer<T>`. | functional | [#buffer-types](../../../design/ast-reference/types.md#buffer-types) | [`structuredbuffer-readonly-hlsl-emit.slang`](structuredbuffer-readonly-hlsl-emit.slang) |
| A DeclRefType carries the generic substitutions that apply to its declaration; two specializations of a generic struct hold values typed as the substituted parameter. | functional | [#declreftype](../../../design/ast-reference/types.md#declreftype) | [`declreftype-generic-substitution.slang`](declreftype-generic-substitution.slang) |
| A struct DeclRefType with mixed-precision fields (half, float, double, int) preserves each field's type through HLSL emission. | expansion | [#declreftype](../../../design/ast-reference/types.md#declreftype) | [`struct-mixed-precision-hlsl-emit.slang`](struct-mixed-precision-hlsl-emit.slang) |
| A struct name is a DeclRefType referencing the StructDecl; a variable declared with that type stores the struct's fields and member access reads them. | functional | [#declreftype](../../../design/ast-reference/types.md#declreftype) | [`declreftype-struct-name.slang`](declreftype-struct-name.slang) |
| Two DeclRefTypes that reference the same generic StructDecl with different generic substitutions are distinct types; one cannot be assigned to the other. | negative | [#declreftype](../../../design/ast-reference/types.md#declreftype) | [`declreftype-substitution-distinguishes.slang`](declreftype-substitution-distinguishes.slang) |
| ErrorType is the type of expressions that failed checking; downstream uses of a failed expression do not produce cascading type-mismatch diagnostics. | negative | [#errortype-and-bottomtype](../../../design/ast-reference/types.md#errortype-and-bottomtype) | [`errortype-cascading-suppression.slang`](errortype-cascading-suppression.slang) |
| A ModifiedType `const T` qualifies the base type with a modifier; writes through a const-modified local are not l-values and are diagnosed. | negative | [#existentials-and-this-types](../../../design/ast-reference/types.md#existentials-and-this-types) | [`modifiedtype-const-rejects-assign.slang`](modifiedtype-const-rejects-assign.slang) |
| A FuncType holds parameter types and a result type; a function-typed value (a callable carrying a FuncType) is invokable to produce its result. | functional | [#functype](../../../design/ast-reference/types.md#functype) | [`functype-callable.slang`](functype-callable.slang) |
| FuncType at "many parameters" (>=8) holds the full param-types list; the callable can be invoked with all 8 args and produces their sum. | stress | [#functype](../../../design/ast-reference/types.md#functype) | [`functype-eight-param-stress.slang`](functype-eight-param-stress.slang) |
| FuncType at the smallest parameter arity (0 parameters) is still a valid function type; the callable returns its result. | boundary | [#functype](../../../design/ast-reference/types.md#functype) | [`functype-zero-param.slang`](functype-zero-param.slang) |
| InitializerListType is the pseudo-type of a brace-initializer before it has been matched; the same `{a, b}` collapses into different concrete types depending on the target. | functional | [#general-purpose-types](../../../design/ast-reference/types.md#general-purpose-types) | [`initializerlisttype-collapse-to-target.slang`](initializerlisttype-collapse-to-target.slang) |
| OverloadGroupType is the pseudo-type of an unresolved overload set; when no target type lets the checker collapse the set, the reference is diagnosed as ambiguous. | negative | [#general-purpose-types](../../../design/ast-reference/types.md#general-purpose-types) | [`overloadgrouptype-ambiguous-rejected.slang`](overloadgrouptype-ambiguous-rejected.slang) |
| An HLSLInputPatchType is the AST type for `InputPatch<T,N>`; the HLSL backend preserves the surface spelling at a hull-shader entry point. | functional | [#geometry--and-tessellation-shader-io-types](../../../design/ast-reference/types.md#geometry--and-tessellation-shader-io-types) | [`input-patch-hull.slang`](input-patch-hull.slang) |
| An HLSLOutputPatchType is the AST type for `OutputPatch<T,N>`; the HLSL backend preserves the surface spelling at a domain-shader entry point. | functional | [#geometry--and-tessellation-shader-io-types](../../../design/ast-reference/types.md#geometry--and-tessellation-shader-io-types) | [`output-patch-domain.slang`](output-patch-domain.slang) |
| An HLSLPointStreamType is the AST type for the geometry-shader `PointStream<T>` output; the HLSL backend preserves the surface spelling and the stream's per-vertex method emits per the documented stream protocol. | functional | [#geometry--and-tessellation-shader-io-types](../../../design/ast-reference/types.md#geometry--and-tessellation-shader-io-types) | [`point-stream-geometry.slang`](point-stream-geometry.slang) |
| An HLSLTriangleStreamType is the AST type for the geometry-shader `TriangleStream<T>` output; the GLSL backend lowers it to per-vertex `EmitVertex()` invocations. | functional | [#geometry--and-tessellation-shader-io-types](../../../design/ast-reference/types.md#geometry--and-tessellation-shader-io-types) | [`triangle-stream-geometry.slang`](triangle-stream-geometry.slang) |
| The VerticesType and IndicesType (mesh-shader `vertices`/`indices` outputs) carry the documented per-output element type; the SPIR-V backend lowers a mesh entry point with both outputs to a mesh-shader execution mode. | functional | [#geometry--and-tessellation-shader-io-types](../../../design/ast-reference/types.md#geometry--and-tessellation-shader-io-types) | [`mesh-output-vertices-indices.slang`](mesh-output-vertices-indices.slang) |
| A ConstantBufferType<T> uniform is the AST type for HLSL `cbuffer`; the HLSL emit renders it as the `cbuffer` keyword. | functional | [#parameter-group-constant-buffer-types](../../../design/ast-reference/types.md#parameter-group-constant-buffer-types) | [`constantbuffertype-hlsl-emit.slang`](constantbuffertype-hlsl-emit.slang) |
| A ParameterBlockType<T> uniform is the AST type for `ParameterBlock<T>`; the HLSL backend lowers it through the parameter-group machinery to a cbuffer block of T's fields. | functional | [#parameter-group-constant-buffer-types](../../../design/ast-reference/types.md#parameter-group-constant-buffer-types) | [`parameterblocktype-hlsl-emit.slang`](parameterblocktype-hlsl-emit.slang) |
| ConstantBufferType<T> with a single-scalar payload (struct of one float) still lowers to HLSL cbuffer at emit; the minimum payload exercises the small edge of the parameter-group machinery. | boundary | [#parameter-group-constant-buffer-types](../../../design/ast-reference/types.md#parameter-group-constant-buffer-types) | [`constantbuffertype-single-scalar.slang`](constantbuffertype-single-scalar.slang) |
| ParameterBlockType<T> with a struct-of-arrays payload still lowers through the parameter-group machinery to a cbuffer-like HLSL block. | boundary | [#parameter-group-constant-buffer-types](../../../design/ast-reference/types.md#parameter-group-constant-buffer-types) | [`parameterblocktype-struct-of-arrays.slang`](parameterblocktype-struct-of-arrays.slang) |
| A PtrType<T> (spelled `T*`) is a raw pointer; dereferencing it through `*p = ...` writes the pointed-to storage. | functional | [#pointer-reference-parameter-passing-types](../../../design/ast-reference/types.md#pointer-reference-parameter-passing-types) | [`ptrtype-dereference.slang`](ptrtype-dereference.slang) |
| BorrowInParamType / OutParamType / BorrowInOutParamType distinguish parameter-passing modes; only `inout` and `out` make callee mutation visible at the caller. | functional | [#pointer-reference-parameter-passing-types](../../../design/ast-reference/types.md#pointer-reference-parameter-passing-types) | [`paramtype-out-inout-in.slang`](paramtype-out-inout-in.slang) |
| NullPtrType is the singleton type of `nullptr`; two pointer locals initialised to nullptr compare equal to each other and to the literal. | boundary | [#pointer-reference-parameter-passing-types](../../../design/ast-reference/types.md#pointer-reference-parameter-passing-types) | [`nullptrtype-equality.slang`](nullptrtype-equality.slang) |
| NullPtrType is the type of `nullptr` (compares equal to a null T*); NoneType is the type of `none` (the empty Optional). | functional | [#pointer-reference-parameter-passing-types](../../../design/ast-reference/types.md#pointer-reference-parameter-passing-types) | [`nonetype-and-nullptrtype.slang`](nonetype-and-nullptrtype.slang) |
| PtrType<T> values can be aliased (two pointers to the same storage); a write through one pointer is observable through the other, and the pointers compare equal. | boundary | [#pointer-reference-parameter-passing-types](../../../design/ast-reference/types.md#pointer-reference-parameter-passing-types) | [`ptrtype-alias-roundtrip.slang`](ptrtype-alias-roundtrip.slang) |
| A DynamicResourceType is the AST type for the bindless `__DynamicResource` handle; the GLSL backend lowers the surface spelling to a binding declaration in a fragment entry point. | functional | [#resource--texture--sampler-types](../../../design/ast-reference/types.md#resource--texture--sampler-types) | [`dynamic-resource-fragment.slang`](dynamic-resource-fragment.slang) |
| A FeedbackType is the AST type for sampler-feedback textures (`FeedbackTexture2D<...>`); the HLSL backend renders the user spelling in a fragment entry point. | functional | [#resource--texture--sampler-types](../../../design/ast-reference/types.md#resource--texture--sampler-types) | [`feedback-texture2d-fragment.slang`](feedback-texture2d-fragment.slang) |
| A RaytracingAccelerationStructureType is the AST type for `RaytracingAccelerationStructure`; the HLSL backend renders it under its documented surface name in a raygeneration entry point. | functional | [#resource--texture--sampler-types](../../../design/ast-reference/types.md#resource--texture--sampler-types) | [`raytracing-acceleration-structure-raygen.slang`](raytracing-acceleration-structure-raygen.slang) |
| A SubpassInputType is the AST type for Vulkan `SubpassInput<T>`; the GLSL backend renders the binding as an `input_attachment_index` decoration in a fragment entry point. | functional | [#resource--texture--sampler-types](../../../design/ast-reference/types.md#resource--texture--sampler-types) | [`subpass-input-fragment.slang`](subpass-input-fragment.slang) |
| A TextureType and SamplerStateType uniform are first-class types; the HLSL backend renders them as `Texture2D<T>` and `SamplerState`. | functional | [#resource-and-texture-type-families](../../../design/ast-reference/types.md#resource-and-texture-type-families) | [`texturetype-samplerstate-hlsl-emit.slang`](texturetype-samplerstate-hlsl-emit.slang) |
| StringType accepts long literal contents; a multi-hundred-character string survives unchanged into emitted CPP target code, including a marker token near its end. | stress | [#string-dynamic-misc](../../../design/ast-reference/types.md#string-dynamic-misc) | [`stringtype-long-literal-stress.slang`](stringtype-long-literal-stress.slang) |
| StringType accepts the empty string literal ""; the empty literal survives to emitted CPP target code as an empty quoted form. | boundary | [#string-dynamic-misc](../../../design/ast-reference/types.md#string-dynamic-misc) | [`stringtype-empty-literal.slang`](stringtype-empty-literal.slang) |
| StringType is the Slang `String` type; a string-typed value's literal text survives lowering to emitted target code. | functional | [#string-dynamic-misc](../../../design/ast-reference/types.md#string-dynamic-misc) | [`stringtype-literal-emitted.slang`](stringtype-literal-emitted.slang) |
| A ThisType inside an interface stands for the conforming type; a method whose return type is `This` returns the concrete type when dispatched on a concrete value. | functional | [#thistype-and-assoctypedecl](../../../design/ast-reference/types.md#thistype-and-assoctypedecl) | [`thistype-interface-method.slang`](thistype-interface-method.slang) |


## Untested claims
| Claim | Reason | Anchor | Why untested |
| --- | --- | --- | --- |
| The **`## Family hierarchy`** mermaid diagram itself. | (unclassified) | (unspecified) | Reason and explanation to be refined by the next regeneration. |
| **Abstract intermediates** from the family hierarchy (`ArithmeticExpressionType`, `Fp8Type`, `BuiltinType`, `DataLayoutType`, `PointerLikeType`, `BuiltinGenericType`, `ResourceType`, `TextureTypeBase`, `TextureShapeType`, `HLSLStructuredBufferTypeBase`, `ParameterGroupType`, `OutParamTypeBase`, `PtrTypeBase`, `ParamPassingModeType`, `UniformParameterGroupType`, `VaryingParameterGroupType`, `UntypedBufferResourceType`, `StringTypeBase`). Each carries no FIDDLE concrete tag and produces no user spelling of its own. | (unclassified) | [#arithmeticexpressiontype](../../../design/ast-reference/types.md#arithmeticexpressiontype) | Reason and explanation to be refined by the next regeneration. |
| **`AtomicType`** — surface spelling exists (`Atomic<T>`) but observable behavior depends on the target; recorded as a doc gap above. | (unclassified) | [#atomictype](../../../design/ast-reference/types.md#atomictype) | Reason and explanation to be refined by the next regeneration. |
| **`BottomType`** — bottom of the type lattice, named in the doc as "the result type of expressions that do not return (e.g. `throw`)". It is a type-lattice abstraction whose only surface trigger (`throw`) has no portable, deterministic observation through any `slang-test` directive (per `_common.md`'s INTERPRET lesson). | implementation-detail | [#bottomtype](../../../design/ast-reference/types.md#bottomtype) | A type-lattice abstraction with no user-observable consequence at any pipeline stage. |
| **`ConditionalType`** — no surface spelling documented; doc gap above. | (unclassified) | [#conditionaltype](../../../design/ast-reference/types.md#conditionaltype) | Reason and explanation to be refined by the next regeneration. |
| **`CoopVectorExpressionType`**, **`DifferentialPairType`**, **`DifferentialPtrPairType`** — subsystem-specific (cooperative math, autodiff); observable surface belongs to those feature bundles. | (unclassified) | [#coopvectorexpressiontype](../../../design/ast-reference/types.md#coopvectorexpressiontype) | Reason and explanation to be refined by the next regeneration. |
| **Data-layout marker types** (`DefaultDataLayoutType`, `Std430DataLayoutType`, `Std140DataLayoutType`, `ScalarDataLayoutType`, `CDataLayoutType`, `DefaultPushConstantDataLayoutType`, `IBufferDataLayoutType`) — visible only inside the buffer-type encoding; not user-spellable in surface Slang. | (unclassified) | [#defaultdatalayouttype](../../../design/ast-reference/types.md#defaultdatalayouttype) | Reason and explanation to be refined by the next regeneration. |
| **Differentiable-function marker types** (`DifferentiableType`, `DifferentiablePtrType`, `DefaultInitializableType`, `FunctionBaseType`, `DifferentiableFuncBaseType`, `ForwardDiffFuncInterfaceType`, `BwdCallableBaseType`, `BwdDiffFuncInterfaceType`, `LegacyBwdDiffFuncInterfaceType`, `FwdDiffFuncType`, `BwdDiffFuncType`, `BwdCallableFuncType`, `ApplyForBwdFuncType`, `RematFuncType`) — produced by autodiff machinery; observable through the differentiate-expression family (`ast-reference/expressions`). | (unclassified) | [#differentiabletype](../../../design/ast-reference/types.md#differentiabletype) | Reason and explanation to be refined by the next regeneration. |
| **`DynamicType`** — the dynamic-dispatch erased type, produced by existential elimination. Not user-spellable. | (unclassified) | [#dynamictype](../../../design/ast-reference/types.md#dynamictype) | Reason and explanation to be refined by the next regeneration. |
| **All pack / variadic types** (`EachType`, `ExpandType`, `PackBranchType`, `FirstPackElementType`, `LastPackElementType`, `TrimFirstTypePack`, `TrimLastTypePack`, `ConcreteTypePack`, `ValuePackType`) — observable through the pack-expression family (covered by `ast-reference/expressions`'s pack-related tests and the future `language-feature/generics-and-packs` bundle). | (unclassified) | [#eachtype](../../../design/ast-reference/types.md#eachtype) | Reason and explanation to be refined by the next regeneration. |
| **`EnumTypeType`** — the "kind" of an enum type; no surface observation distinct from `EnumDecl` (covered in `ast-reference/declarations`). | (unclassified) | [#enumtypetype](../../../design/ast-reference/types.md#enumtypetype) | Reason and explanation to be refined by the next regeneration. |
| **Synthesized / lowering-only types** with no user-written spelling: `ExtractExistentialType`, `ExistentialSpecializedType`, `GenericDeclRefType`, `NamespaceType`, `NativeRefType`, `ExplicitRefType`. These are produced by lowering / specialization passes (existential opening, generic specialization), not by user-written code. | link-stage-only | [#extractexistentialtype](../../../design/ast-reference/types.md#extractexistentialtype) | These nodes only exist after lowering / specialization passes; this bundle's `pipeline_stage` is `check`/`emit`-level, so the post-lowering nodes have no surface observation here. |
| **Fp8 family** (`FloatE4M3Type`, `FloatE5M2Type`, `BFloat16Type`) — storage-only floats; surface support varies by target. | (unclassified) | [#floate4m3type](../../../design/ast-reference/types.md#floate4m3type) | Reason and explanation to be refined by the next regeneration. |
| **GLSL-only types** (`GLSLImageType`, `GLSLShaderStorageBufferType`, `GLSLInputParameterGroupType`, `GLSLOutputParameterGroupType`, `GLSLAtomicUintType`, `GLSLInputAttachmentType`) — observable only via GLSL-source ingest; not exercised here. | (unclassified) | [#glslimagetype](../../../design/ast-reference/types.md#glslimagetype) | Reason and explanation to be refined by the next regeneration. |
| **Operand-list layout** described under "Key fields" in `## Nodes` ("operand-encoded", "(element-type, count operand-encoded)", ...). The `m_operands: List<ValNodeOperand>` storage and the indices each concrete class uses are not visible at the surface. | (unclassified) | [#key-fields](../../../design/ast-reference/types.md#key-fields) | Reason and explanation to be refined by the next regeneration. |
| **`NamedExpressionType`** — alias-name diagnostic preservation does not hold on the current implementation; doc gap above. The semantic interchangeability of an alias with the original type is covered by `ast-reference/declarations/typedefdecl.slang` and `ast-reference/declarations/typealiasdecl.slang`. | (unclassified) | [#namedexpressiontype](../../../design/ast-reference/types.md#namedexpressiontype) | Reason and explanation to be refined by the next regeneration. |
| **`NativeStringType`** — internal native `const char*`-style string used in low-level lowering; not user-spellable. | (unclassified) | [#nativestringtype](../../../design/ast-reference/types.md#nativestringtype) | Reason and explanation to be refined by the next regeneration. |
| **Internal C++ parent class** of any concrete `Type` (e.g. that `VectorExpressionType` extends `ArithmeticExpressionType`, that `Fp8Type` extends `DeclRefType`, that `BuiltinGenericType` extends `BuiltinType`). | needs-unit-test | [#type](../../../design/ast-reference/types.md#type) | Only the user-observable role of each leaf is testable. |
| **Singleton-ness / hash-cons identity** of pseudo-types (`ErrorType`, `BottomType`, `NullPtrType`, `NoneType`, `OverloadGroupType`, `InitializerListType` are each one-per- `ASTBuilder`). Two textually identical Slang types share the same `Val*` after hash-cons, but the surface only sees the post-hoist behavior, not the identity. | implementation-detail | [#errortype](../../../design/ast-reference/types.md#errortype) | Internal compiler choice (pass ordering, hoistability decisions, deduplication) with no test-directive that reveals it. |


## Doc gaps observed
| Anchor | Kind | Gap | Suggested addition |
| --- | --- | --- | --- |
| [#a-typedefd-typealiasd-type-that-preserves-the-original-name-for-diagnostics](../../../design/ast-reference/types.md#a-typedefd-typealiasd-type-that-preserves-the-original-name-for-diagnostics) | undocumented-behavior | The doc names `NamedExpressionType` as "a typedef'd / typealias'd type that preserves the original name for diagnostics". In practice, both `typedef T Y;` and `typealias Y = T;` produce a type-mismatch diagnostic that renders the **underlying** type's name, not the alias name. | Either the doc's claim about diagnostic-preservation should be removed, or the diagnostic renderer needs to look through `NamedExpressionType` differently. No test in this bundle exercises that claim; recording as a gap. |
| [#compile-time-conditional-type](../../../design/ast-reference/types.md#compile-time-conditional-type) | undocumented-behavior | The doc says `ConditionalType` is "compile-time conditional type" but does not name a user-spelling production. The grammar pointer is empty `(none)`; without a surface form this is not testable through `slangc`. A doc-level pointer to the conditional-type spelling (or a note saying it is checker-synthesized) would resolve this. |  |
| [#atomic-wrapper-type](../../../design/ast-reference/types.md#atomic-wrapper-type) | undocumented-behavior | `AtomicType` is "atomic wrapper type" in the doc with grammar `(none)`. `Atomic<T>` is a surface spelling but its observable behavior depends on the target (groupshared / structured-buffer) and is not portable on the no-GPU runner. A doc-level pointer to the minimal portable observation would let an agent anchor a test. |  |
| [#the-type-of-an-enum-type-itself-its-kind](../../../design/ast-reference/types.md#the-type-of-an-enum-type-itself-its-kind) | undocumented-behavior | The doc lists `EnumTypeType` as "the type of an `enum` type itself (its kind)". The user-facing claim is unclear: an enum used as a type is observable (covered by `ast-reference/declarations/enumdecl-tagged-union.slang`), but the "type of the enum type" itself is a kind-level claim that has no obvious surface. Recording as a gap. |  |
| [#bottom-type-representing-no-value-used-in-the-type-lattice](../../../design/ast-reference/types.md#bottom-type-representing-no-value-used-in-the-type-lattice) | undocumented-behavior | The doc lists `BottomType` as "bottom type representing 'no value'; used in the type lattice". The note says it is "used as the result type of expressions that do not return (e.g. throw)". `throw` is unobservable under INTERPRET (per `_common.md` lessons); a portable-on-no-GPU surface would be needed to test this. |  |
| [#texturetype](../../../design/ast-reference/types.md#texturetype) | undocumented-behavior | The doc lists 9 operands for `TextureType` but does not enumerate them. The observable surface (one test that observes the presence of `Texture2D<T>` on the HLSL backend) covers only the first operand. A doc-level table of the 9 operands and which surface spellings select each combination would let agents anchor finer-grained tests. |  |
| [#fp8](../../../design/ast-reference/types.md#fp8) | missing-surface | The doc lists a "Fp8" family (`FloatE4M3Type`, `FloatE5M2Type`) and a `BFloat16Type` but no portable surface for these is documented. The user-spelling appears target-gated; a doc-level pointer to the minimal targetable spelling would let an agent anchor a test. |  |
| [#differential-pair-primal-differential-used-by-autodiff](../../../design/ast-reference/types.md#differential-pair-primal-differential-used-by-autodiff) | undocumented-behavior | `DifferentialPairType` and `DifferentialPtrPairType` are "differential pair (primal, differential) used by autodiff". Observable only through `[Differentiable]` machinery; the autodiff feature lives in a separate bundle. A doc pointer to that bundle would clarify boundary ownership. |  |


## Bootstrap test issues observed
(none)


## Compiler-bug observations
- Under `slangi` (INTERPRET), elementwise add of two
  `vector<half, N>` values aborts with
  `Cannot find execution handler for instruction add.f16v2`
  (and presumably `add.f16v3` / `add.f16v4`). Scalar half add via
  per-lane reads works fine. The expansion tests
  `vec2-half-arithmetic.slang` and `vec3-half-arithmetic.slang`
  therefore add per-lane, not at the vector level.
- Under `slangi`, casting a `half` lane read from a
  `matrix<half, R, C>` to `int` or `float` aborts with
  `Cannot find execution handler for instruction cast.i32.f16` /
  `cast.f32.f16` even though the same cast works for a scalar
  `half` local. The half-matrix corner is therefore observed
  through `-target hlsl` text emission
  (`mat3x3-half-hlsl-emit.slang`) instead of INTERPRET.
- Under `slangi`, `isnan(...)` and `isinf(...)` resolve to
  intrinsics whose `__target_switch` has no interpreter-
  compatible branch (`E41011`). The float-inf/nan vector
  boundary test (`vec3-float-inf-nan.slang`) uses the
  documented `x != x` (NaN) and `x > 1e38f` (inf) per-lane
  predicates instead.
- Under `slangi`, default-initializing a struct that contains a
  `half` field and then writing each field by assignment aborts
  with SIGSEGV (138/139). Using an aggregate initializer
  (`Mixed m = { half(1.5), ..., 4 };`) crashes the interpreter
  too. The struct-mixed-precision observation
  (`struct-mixed-precision-hlsl-emit.slang`) therefore uses
  `-target hlsl` text emission instead of INTERPRET.
