| export const description = `Validation tests for identifiers`; |
| |
| import { makeTestGroup } from '../../../../common/framework/test_group.js'; |
| import { keysOf } from '../../../../common/util/data_tables.js'; |
| import { ShaderValidationTest } from '../shader_validation_test.js'; |
| |
| export const g = makeTestGroup(ShaderValidationTest); |
| |
| g.test('function_param') |
| .desc( |
| `Test that a function param can shadow a builtin, but the builtin is available for other params.` |
| ) |
| .fn(t => { |
| const code = ` |
| fn f(f: i32, i32: i32, t: i32) -> i32 { return i32; } |
| `; |
| t.expectCompileResult(true, code); |
| }); |
| |
| const kTests = { |
| abs: { |
| keyword: `abs`, |
| src: `_ = abs(1);`, |
| }, |
| acos: { |
| keyword: `acos`, |
| src: `_ = acos(.2);`, |
| }, |
| acosh: { |
| keyword: `acosh`, |
| src: `_ = acosh(1.2);`, |
| }, |
| all: { |
| keyword: `all`, |
| src: `_ = all(true);`, |
| }, |
| any: { |
| keyword: `any`, |
| src: `_ = any(true);`, |
| }, |
| array_templated: { |
| keyword: `array`, |
| src: `_ = array<i32, 2>(1, 2);`, |
| }, |
| array: { |
| keyword: `array`, |
| src: `_ = array(1, 2);`, |
| }, |
| array_length: { |
| keyword: `arrayLength`, |
| src: `_ = arrayLength(&placeholder.rt_arr);`, |
| }, |
| asin: { |
| keyword: `asin`, |
| src: `_ = asin(.2);`, |
| }, |
| asinh: { |
| keyword: `asinh`, |
| src: `_ = asinh(1.2);`, |
| }, |
| atan: { |
| keyword: `atan`, |
| src: `_ = atan(1.2);`, |
| }, |
| atanh: { |
| keyword: `atanh`, |
| src: `_ = atanh(.2);`, |
| }, |
| atan2: { |
| keyword: `atan2`, |
| src: `_ = atan2(1.2, 2.3);`, |
| }, |
| bool: { |
| keyword: `bool`, |
| src: `_ = bool(1);`, |
| }, |
| bitcast: { |
| keyword: `bitcast`, |
| src: `_ = bitcast<f32>(1i);`, |
| }, |
| ceil: { |
| keyword: `ceil`, |
| src: `_ = ceil(1.23);`, |
| }, |
| clamp: { |
| keyword: `clamp`, |
| src: `_ = clamp(1, 2, 3);`, |
| }, |
| cos: { |
| keyword: `cos`, |
| src: `_ = cos(2);`, |
| }, |
| cosh: { |
| keyword: `cosh`, |
| src: `_ = cosh(2.2);`, |
| }, |
| countLeadingZeros: { |
| keyword: `countLeadingZeros`, |
| src: `_ = countLeadingZeros(1);`, |
| }, |
| countOneBits: { |
| keyword: `countOneBits`, |
| src: `_ = countOneBits(1);`, |
| }, |
| countTrailingZeros: { |
| keyword: `countTrailingZeros`, |
| src: `_ = countTrailingZeros(1);`, |
| }, |
| cross: { |
| keyword: `cross`, |
| src: `_ = cross(vec3(1, 2, 3), vec3(4, 5, 6));`, |
| }, |
| degrees: { |
| keyword: `degrees`, |
| src: `_ = degrees(1);`, |
| }, |
| determinant: { |
| keyword: `determinant`, |
| src: `_ = determinant(mat2x2(1, 2, 3, 4));`, |
| }, |
| distance: { |
| keyword: `distance`, |
| src: `_ = distance(1, 2);`, |
| }, |
| dot: { |
| keyword: `dot`, |
| src: `_ = dot(vec2(1, 2,), vec2(2, 3));`, |
| }, |
| dot4U8Packed: { |
| keyword: `dot4U8Packed`, |
| src: `_ = dot4U8Packed(1, 2);`, |
| }, |
| dot4I8Packed: { |
| keyword: `dot4I8Packed`, |
| src: `_ = dot4I8Packed(1, 2);`, |
| }, |
| dpdx: { |
| keyword: `dpdx`, |
| src: `_ = dpdx(2);`, |
| }, |
| dpdxCoarse: { |
| keyword: `dpdxCoarse`, |
| src: `_ = dpdxCoarse(2);`, |
| }, |
| dpdxFine: { |
| keyword: `dpdxFine`, |
| src: `_ = dpdxFine(2);`, |
| }, |
| dpdy: { |
| keyword: `dpdy`, |
| src: `_ = dpdy(2);`, |
| }, |
| dpdyCoarse: { |
| keyword: `dpdyCoarse`, |
| src: `_ = dpdyCoarse(2);`, |
| }, |
| dpdyFine: { |
| keyword: `dpdyFine`, |
| src: `_ = dpdyFine(2);`, |
| }, |
| exp: { |
| keyword: `exp`, |
| src: `_ = exp(1);`, |
| }, |
| exp2: { |
| keyword: `exp2`, |
| src: `_ = exp2(2);`, |
| }, |
| extractBits: { |
| keyword: `extractBits`, |
| src: `_ = extractBits(1, 2, 3);`, |
| }, |
| f32: { |
| keyword: `f32`, |
| src: `_ = f32(1i);`, |
| }, |
| faceForward: { |
| keyword: `faceForward`, |
| src: `_ = faceForward(vec2(1, 2), vec2(3, 4), vec2(5, 6));`, |
| }, |
| firstLeadingBit: { |
| keyword: `firstLeadingBit`, |
| src: `_ = firstLeadingBit(1);`, |
| }, |
| firstTrailingBit: { |
| keyword: `firstTrailingBit`, |
| src: `_ = firstTrailingBit(1);`, |
| }, |
| floor: { |
| keyword: `floor`, |
| src: `_ = floor(1.2);`, |
| }, |
| fma: { |
| keyword: `fma`, |
| src: `_ = fma(1, 2, 3);`, |
| }, |
| fract: { |
| keyword: `fract`, |
| src: `_ = fract(1);`, |
| }, |
| frexp: { |
| keyword: `frexp`, |
| src: `_ = frexp(1);`, |
| }, |
| fwidth: { |
| keyword: `fwidth`, |
| src: `_ = fwidth(2);`, |
| }, |
| fwidthCoarse: { |
| keyword: `fwidthCoarse`, |
| src: `_ = fwidthCoarse(2);`, |
| }, |
| fwidthFine: { |
| keyword: `fwidthFine`, |
| src: `_ = fwidthFine(2);`, |
| }, |
| i32: { |
| keyword: `i32`, |
| src: `_ = i32(2u);`, |
| }, |
| insertBits: { |
| keyword: `insertBits`, |
| src: `_ = insertBits(1, 2, 3, 4);`, |
| }, |
| inverseSqrt: { |
| keyword: `inverseSqrt`, |
| src: `_ = inverseSqrt(1);`, |
| }, |
| ldexp: { |
| keyword: `ldexp`, |
| src: `_ = ldexp(1, 2);`, |
| }, |
| length: { |
| keyword: `length`, |
| src: `_ = length(1);`, |
| }, |
| log: { |
| keyword: `log`, |
| src: `_ = log(2);`, |
| }, |
| log2: { |
| keyword: `log2`, |
| src: `_ = log2(2);`, |
| }, |
| mat2x2_templated: { |
| keyword: `mat2x2`, |
| src: `_ = mat2x2<f32>(1, 2, 3, 4);`, |
| }, |
| mat2x2: { |
| keyword: `mat2x2`, |
| src: `_ = mat2x2(1, 2, 3, 4);`, |
| }, |
| mat2x3_templated: { |
| keyword: `mat2x3`, |
| src: `_ = mat2x3<f32>(1, 2, 3, 4, 5, 6);`, |
| }, |
| mat2x3: { |
| keyword: `mat2x3`, |
| src: `_ = mat2x3(1, 2, 3, 4, 5, 6);`, |
| }, |
| mat2x4_templated: { |
| keyword: `mat2x4`, |
| src: `_ = mat2x4<f32>(1, 2, 3, 4, 5, 6, 7, 8);`, |
| }, |
| mat2x4: { |
| keyword: `mat2x4`, |
| src: `_ = mat2x4(1, 2, 3, 4, 5, 6, 7, 8);`, |
| }, |
| mat3x2_templated: { |
| keyword: `mat3x2`, |
| src: `_ = mat3x2<f32>(1, 2, 3, 4, 5, 6);`, |
| }, |
| mat3x2: { |
| keyword: `mat3x2`, |
| src: `_ = mat3x2(1, 2, 3, 4, 5, 6);`, |
| }, |
| mat3x3_templated: { |
| keyword: `mat3x3`, |
| src: `_ = mat3x3<f32>(1, 2, 3, 4, 5, 6, 7, 8, 9);`, |
| }, |
| mat3x3: { |
| keyword: `mat3x3`, |
| src: `_ = mat3x3(1, 2, 3, 4, 5, 6, 7, 8, 9);`, |
| }, |
| mat3x4_templated: { |
| keyword: `mat3x4`, |
| src: `_ = mat3x4<f32>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);`, |
| }, |
| mat3x4: { |
| keyword: `mat3x4`, |
| src: `_ = mat3x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);`, |
| }, |
| mat4x2_templated: { |
| keyword: `mat4x2`, |
| src: `_ = mat4x2<f32>(1, 2, 3, 4, 5, 6, 7, 8);`, |
| }, |
| mat4x2: { |
| keyword: `mat4x2`, |
| src: `_ = mat4x2(1, 2, 3, 4, 5, 6, 7, 8);`, |
| }, |
| mat4x3_templated: { |
| keyword: `mat4x3`, |
| src: `_ = mat4x3<f32>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);`, |
| }, |
| mat4x3: { |
| keyword: `mat4x3`, |
| src: `_ = mat4x3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);`, |
| }, |
| mat4x4_templated: { |
| keyword: `mat4x4`, |
| src: `_ = mat4x4<f32>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);`, |
| }, |
| mat4x4: { |
| keyword: `mat4x4`, |
| src: `_ = mat4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);`, |
| }, |
| max: { |
| keyword: `max`, |
| src: `_ = max(1, 2);`, |
| }, |
| min: { |
| keyword: `min`, |
| src: `_ = min(1, 2);`, |
| }, |
| mix: { |
| keyword: `mix`, |
| src: `_ = mix(1, 2, 3);`, |
| }, |
| modf: { |
| keyword: `modf`, |
| src: `_ = modf(1.2);`, |
| }, |
| normalize: { |
| keyword: `normalize`, |
| src: `_ = normalize(vec2(1, 2));`, |
| }, |
| pack2x16snorm: { |
| keyword: `pack2x16snorm`, |
| src: `_ = pack2x16snorm(vec2(1, 2));`, |
| }, |
| pack2x16unorm: { |
| keyword: `pack2x16unorm`, |
| src: `_ = pack2x16unorm(vec2(1, 2));`, |
| }, |
| pack2x16float: { |
| keyword: `pack2x16float`, |
| src: `_ = pack2x16float(vec2(1, 2));`, |
| }, |
| pack4x8snorm: { |
| keyword: `pack4x8snorm`, |
| src: `_ = pack4x8snorm(vec4(1, 2, 3, 4));`, |
| }, |
| pack4x8unorm: { |
| keyword: `pack4x8unorm`, |
| src: `_ = pack4x8unorm(vec4(1, 2, 3, 4));`, |
| }, |
| pack4xI8: { |
| keyword: `pack4xI8`, |
| src: `_ = pack4xI8(vec4(1, 2, 3, 4));`, |
| }, |
| pack4xU8: { |
| keyword: `pack4xU8`, |
| src: `_ = pack4xU8(vec4(1, 2, 3, 4));`, |
| }, |
| pack4xI8Clamp: { |
| keyword: `pack4xI8Clamp`, |
| src: `_ = pack4xI8Clamp(vec4(1, 2, 3, 4));`, |
| }, |
| pack4xU8Clamp: { |
| keyword: `pack4xU8Clamp`, |
| src: `_ = pack4xU8Clamp(vec4(1, 2, 3, 4));`, |
| }, |
| pow: { |
| keyword: `pow`, |
| src: `_ = pow(1, 2);`, |
| }, |
| quantizeToF16: { |
| keyword: `quantizeToF16`, |
| src: `_ = quantizeToF16(1.2);`, |
| }, |
| radians: { |
| keyword: `radians`, |
| src: `_ = radians(1.2);`, |
| }, |
| reflect: { |
| keyword: `reflect`, |
| src: `_ = reflect(vec2(1, 2), vec2(3, 4));`, |
| }, |
| refract: { |
| keyword: `refract`, |
| src: `_ = refract(vec2(1, 1), vec2(2, 2), 3);`, |
| }, |
| reverseBits: { |
| keyword: `reverseBits`, |
| src: `_ = reverseBits(1);`, |
| }, |
| round: { |
| keyword: `round`, |
| src: `_ = round(1.2);`, |
| }, |
| saturate: { |
| keyword: `saturate`, |
| src: `_ = saturate(1);`, |
| }, |
| select: { |
| keyword: `select`, |
| src: `_ = select(1, 2, false);`, |
| }, |
| sign: { |
| keyword: `sign`, |
| src: `_ = sign(1);`, |
| }, |
| sin: { |
| keyword: `sin`, |
| src: `_ = sin(2);`, |
| }, |
| sinh: { |
| keyword: `sinh`, |
| src: `_ = sinh(3);`, |
| }, |
| smoothstep: { |
| keyword: `smoothstep`, |
| src: `_ = smoothstep(1, 2, 3);`, |
| }, |
| sqrt: { |
| keyword: `sqrt`, |
| src: `_ = sqrt(24);`, |
| }, |
| step: { |
| keyword: `step`, |
| src: `_ = step(4, 5);`, |
| }, |
| tan: { |
| keyword: `tan`, |
| src: `_ = tan(2);`, |
| }, |
| tanh: { |
| keyword: `tanh`, |
| src: `_ = tanh(2);`, |
| }, |
| transpose: { |
| keyword: `transpose`, |
| src: `_ = transpose(mat2x2(1, 2, 3, 4));`, |
| }, |
| trunc: { |
| keyword: `trunc`, |
| src: `_ = trunc(2);`, |
| }, |
| u32: { |
| keyword: `u32`, |
| src: `_ = u32(1i);`, |
| }, |
| unpack2x16snorm: { |
| keyword: `unpack2x16snorm`, |
| src: `_ = unpack2x16snorm(2);`, |
| }, |
| unpack2x16unorm: { |
| keyword: `unpack2x16unorm`, |
| src: `_ = unpack2x16unorm(2);`, |
| }, |
| unpack2x16float: { |
| keyword: `unpack2x16float`, |
| src: `_ = unpack2x16float(2);`, |
| }, |
| unpack4x8snorm: { |
| keyword: `unpack4x8snorm`, |
| src: `_ = unpack4x8snorm(4);`, |
| }, |
| unpack4x8unorm: { |
| keyword: `unpack4x8unorm`, |
| src: `_ = unpack4x8unorm(4);`, |
| }, |
| unpack4xI8: { |
| keyword: `unpack4xI8`, |
| src: `_ = unpack4xI8(4);`, |
| }, |
| unpack4xU8: { |
| keyword: `unpack4xU8`, |
| src: `_ = unpack4xU8(4);`, |
| }, |
| vec2_templated: { |
| keyword: `vec2`, |
| src: `_ = vec2<f32>(1, 2);`, |
| }, |
| vec2: { |
| keyword: `vec2`, |
| src: `_ = vec2(1, 2);`, |
| }, |
| vec3_templated: { |
| keyword: `vec3`, |
| src: `_ = vec3<f32>(1, 2, 3);`, |
| }, |
| vec3: { |
| keyword: `vec3`, |
| src: `_ = vec3(1, 2, 3);`, |
| }, |
| vec4_templated: { |
| keyword: `vec4`, |
| src: `_ = vec4<f32>(1, 2, 3, 4);`, |
| }, |
| vec4: { |
| keyword: `vec4`, |
| src: `_ = vec4(1, 2, 3, 4);`, |
| }, |
| }; |
| |
| g.test('shadow_hides_builtin') |
| .desc(`Test that shadows hide builtins.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'sibling', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kTests)) |
| ) |
| .fn(t => { |
| const data = kTests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : i32;` : ``; |
| const sibling_func = t.params.inject === 'sibling' ? local : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| struct Data { |
| rt_arr: array<i32>, |
| } |
| @group(0) @binding(0) var<storage> placeholder: Data; |
| |
| ${module_shadow} |
| |
| fn sibling() { |
| ${sibling_func} |
| } |
| |
| @fragment |
| fn main() -> @location(0) vec4f { |
| ${func} |
| ${data.src} |
| return vec4f(1); |
| } |
| `; |
| |
| const pass = t.params.inject === 'none' || t.params.inject === 'sibling'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| const kFloat16Tests = { |
| f16: { |
| keyword: `f16`, |
| src: `_ = f16(2);`, |
| }, |
| }; |
| |
| g.test('shadow_hides_builtin_f16') |
| .desc(`Test that shadows hide builtins when shader-f16 is enabled.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'sibling', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kFloat16Tests)) |
| ) |
| .fn(t => { |
| const data = kFloat16Tests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : f16;` : ``; |
| const sibling_func = t.params.inject === 'sibling' ? local : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| enable f16; |
| |
| ${module_shadow} |
| |
| fn sibling() { |
| ${sibling_func} |
| } |
| |
| @vertex |
| fn vtx() -> @builtin(position) vec4f { |
| ${func} |
| ${data.src} |
| return vec4f(1); |
| } |
| `; |
| const pass = t.params.inject === 'none' || t.params.inject === 'sibling'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| const kTextureTypeTests = { |
| texture_1d: { |
| keyword: `texture_1d`, |
| src: `var t: texture_1d<f32>;`, |
| }, |
| texture_2d: { |
| keyword: `texture_2d`, |
| src: `var t: texture_2d<f32>;`, |
| }, |
| texture_2d_array: { |
| keyword: `texture_2d_array`, |
| src: `var t: texture_2d_array<f32>;`, |
| }, |
| texture_3d: { |
| keyword: `texture_3d`, |
| src: `var t: texture_3d<f32>;`, |
| }, |
| texture_cube: { |
| keyword: `texture_cube`, |
| src: `var t: texture_cube<f32>;`, |
| }, |
| texture_cube_array: { |
| keyword: `texture_cube_array`, |
| src: `var t: texture_cube_array<f32>;`, |
| }, |
| texture_multisampled_2d: { |
| keyword: `texture_multisampled_2d`, |
| src: `var t: texture_multisampled_2d<f32>;`, |
| }, |
| texture_depth_multisampled_2d: { |
| keyword: `texture_depth_multisampled_2d`, |
| src: `var t: texture_depth_multisampled_2d;`, |
| }, |
| texture_external: { |
| keyword: `texture_external`, |
| src: `var t: texture_external;`, |
| }, |
| texture_storage_1d: { |
| keyword: `texture_storage_1d`, |
| src: `var t: texture_storage_1d<rgba8unorm, read_write>;`, |
| }, |
| texture_storage_2d: { |
| keyword: `texture_storage_2d`, |
| src: `var t: texture_storage_2d<rgba8unorm, read_write>;`, |
| }, |
| texture_storage_2d_array: { |
| keyword: `texture_storage_2d_array`, |
| src: `var t: texture_storage_2d_array<rgba8unorm, read_write>;`, |
| }, |
| texture_storage_3d: { |
| keyword: `texture_storage_3d`, |
| src: `var t: texture_storage_3d<rgba8unorm, read_write>;`, |
| }, |
| texture_depth_2d: { |
| keyword: `texture_depth_2d`, |
| src: `var t: texture_depth_2d;`, |
| }, |
| texture_depth_2d_array: { |
| keyword: `texture_depth_2d_array`, |
| src: `var t: texture_depth_2d_array;`, |
| }, |
| texture_depth_cube: { |
| keyword: `texture_depth_cube`, |
| src: `var t: texture_depth_cube;`, |
| }, |
| texture_depth_cube_array: { |
| keyword: `texture_depth_cube_array`, |
| src: `var t: texture_depth_cube_array;`, |
| }, |
| sampler: { |
| keyword: `sampler`, |
| src: `var s: sampler;`, |
| }, |
| sampler_comparison: { |
| keyword: `sampler_comparison`, |
| src: `var s: sampler_comparison;`, |
| }, |
| }; |
| |
| g.test('shadow_hides_builtin_handle_type') |
| .desc(`Test that shadows hide builtins when handle address space types are used.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kTextureTypeTests)) |
| ) |
| .fn(t => { |
| const data = kTextureTypeTests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : f32;` : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| ${module_shadow} |
| @group(0) @binding(0) ${data.src} |
| |
| fn func() { |
| ${func} |
| } |
| `; |
| const pass = t.params.inject === 'none' || t.params.inject === 'function'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| const kTextureTests = { |
| textureDimensions: { |
| keyword: `textureDimensions`, |
| src: `_ = textureDimensions(t_2d);`, |
| }, |
| textureGather: { |
| keyword: `textureGather`, |
| src: `_ = textureGather(1, t_2d, s, vec2(1, 2));`, |
| }, |
| textureGatherCompare: { |
| keyword: `textureGatherCompare`, |
| src: `_ = textureGatherCompare(t_2d_depth, sc, vec2(1, 2), 3);`, |
| }, |
| textureLoad: { |
| keyword: `textureLoad`, |
| src: `_ = textureLoad(t_2d, vec2(1, 2), 1);`, |
| }, |
| textureNumLayers: { |
| keyword: `textureNumLayers`, |
| src: `_ = textureNumLayers(t_2d_array);`, |
| }, |
| textureNumLevels: { |
| keyword: `textureNumLevels`, |
| src: `_ = textureNumLevels(t_2d);`, |
| }, |
| textureNumSamples: { |
| keyword: `textureNumSamples`, |
| src: `_ = textureNumSamples(t_2d_ms);`, |
| }, |
| textureSample: { |
| keyword: `textureSample`, |
| src: `_ = textureSample(t_2d, s, vec2(1, 2));`, |
| }, |
| textureSampleBias: { |
| keyword: `textureSampleBias`, |
| src: `_ = textureSampleBias(t_2d, s, vec2(1, 2), 2);`, |
| }, |
| textureSampleCompare: { |
| keyword: `textureSampleCompare`, |
| src: `_ = textureSampleCompare(t_2d_depth, sc, vec2(1, 2), 2);`, |
| }, |
| textureSampleCompareLevel: { |
| keyword: `textureSampleCompareLevel`, |
| src: `_ = textureSampleCompareLevel(t_2d_depth, sc, vec2(1, 2), 3, vec2(1, 2));`, |
| }, |
| textureSampleGrad: { |
| keyword: `textureSampleGrad`, |
| src: `_ = textureSampleGrad(t_2d, s, vec2(1, 2), vec2(1, 2), vec2(1, 2));`, |
| }, |
| textureSampleLevel: { |
| keyword: `textureSampleLevel`, |
| src: `_ = textureSampleLevel(t_2d, s, vec2(1, 2), 3);`, |
| }, |
| textureSampleBaseClampToEdge: { |
| keyword: `textureSampleBaseClampToEdge`, |
| src: `_ = textureSampleBaseClampToEdge(t_2d, s, vec2(1, 2));`, |
| }, |
| }; |
| |
| g.test('shadow_hides_builtin_texture') |
| .desc(`Test that shadows hide texture builtins.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'sibling', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kTextureTests)) |
| ) |
| .fn(t => { |
| const data = kTextureTests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : i32;` : ``; |
| const sibling_func = t.params.inject === 'sibling' ? local : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| @group(0) @binding(0) var t_2d: texture_2d<f32>; |
| @group(0) @binding(1) var t_2d_depth: texture_depth_2d; |
| @group(0) @binding(2) var t_2d_array: texture_2d_array<f32>; |
| @group(0) @binding(3) var t_2d_ms: texture_multisampled_2d<f32>; |
| |
| @group(1) @binding(0) var s: sampler; |
| @group(1) @binding(1) var sc: sampler_comparison; |
| |
| ${module_shadow} |
| |
| fn sibling() { |
| ${sibling_func} |
| } |
| |
| @fragment |
| fn main() -> @location(0) vec4f { |
| ${func} |
| ${data.src} |
| return vec4f(1); |
| } |
| `; |
| |
| const pass = t.params.inject === 'none' || t.params.inject === 'sibling'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| g.test('shadow_hides_builtin_atomic_type') |
| .desc(`Test that shadows hide builtins when atomic types are used.`) |
| .params(u => u.combine('inject', ['none', 'function', 'module'] as const).beginSubcases()) |
| .fn(t => { |
| const local = `let atomic = 4;`; |
| const module_shadow = t.params.inject === 'module' ? `var<private> atomic: i32;` : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| ${module_shadow} |
| |
| var<workgroup> val: atomic<i32>; |
| |
| fn func() { |
| ${func} |
| } |
| `; |
| const pass = t.params.inject === 'none' || t.params.inject === 'function'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| const kAtomicTests = { |
| atomicLoad: { |
| keyword: `atomicLoad`, |
| src: `_ = atomicLoad(&a);`, |
| }, |
| atomicStore: { |
| keyword: `atomicStore`, |
| src: `atomicStore(&a, 1);`, |
| }, |
| atomicAdd: { |
| keyword: `atomicAdd`, |
| src: `_ = atomicAdd(&a, 1);`, |
| }, |
| atomicSub: { |
| keyword: `atomicSub`, |
| src: `_ = atomicSub(&a, 1);`, |
| }, |
| atomicMax: { |
| keyword: `atomicMax`, |
| src: `_ = atomicMax(&a, 1);`, |
| }, |
| atomicMin: { |
| keyword: `atomicMin`, |
| src: `_ = atomicMin(&a, 1);`, |
| }, |
| atomicAnd: { |
| keyword: `atomicAnd`, |
| src: `_ = atomicAnd(&a, 1);`, |
| }, |
| atomicOr: { |
| keyword: `atomicOr`, |
| src: `_ = atomicOr(&a, 1);`, |
| }, |
| atomicXor: { |
| keyword: `atomicXor`, |
| src: `_ = atomicXor(&a, 1);`, |
| }, |
| }; |
| |
| g.test('shadow_hides_builtin_atomic') |
| .desc(`Test that shadows hide builtin atomic methods.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'sibling', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kAtomicTests)) |
| ) |
| .fn(t => { |
| const data = kAtomicTests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : i32;` : ``; |
| const sibling_func = t.params.inject === 'sibling' ? local : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| var<workgroup> a: atomic<i32>; |
| |
| ${module_shadow} |
| |
| fn sibling() { |
| ${sibling_func} |
| } |
| |
| @compute @workgroup_size(1) |
| fn main() { |
| ${func} |
| ${data.src} |
| } |
| `; |
| |
| const pass = t.params.inject === 'none' || t.params.inject === 'sibling'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| const kBarrierTests = { |
| storageBarrier: { |
| keyword: `storageBarrier`, |
| src: `storageBarrier();`, |
| }, |
| textureBarrier: { |
| keyword: `textureBarrier`, |
| src: `textureBarrier();`, |
| }, |
| workgroupBarrier: { |
| keyword: `workgroupBarrier`, |
| src: `workgroupBarrier();`, |
| }, |
| workgroupUniformLoad: { |
| keyword: `workgroupUniformLoad`, |
| src: `_ = workgroupUniformLoad(&u);`, |
| }, |
| }; |
| |
| g.test('shadow_hides_builtin_barriers') |
| .desc(`Test that shadows hide builtin barrier methods.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'sibling', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kBarrierTests)) |
| ) |
| .fn(t => { |
| const data = kBarrierTests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : i32;` : ``; |
| const sibling_func = t.params.inject === 'sibling' ? local : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| var<workgroup> u: u32; |
| |
| ${module_shadow} |
| |
| fn sibling() { |
| ${sibling_func} |
| } |
| |
| @compute @workgroup_size(1) |
| fn main() { |
| ${func} |
| ${data.src} |
| } |
| `; |
| |
| const pass = t.params.inject === 'none' || t.params.inject === 'sibling'; |
| t.expectCompileResult(pass, code); |
| }); |
| |
| const kAccessModeTests = { |
| read: { |
| keyword: `read`, |
| src: `var<storage, read> a: i32;`, |
| }, |
| read_write: { |
| keyword: `read_write`, |
| src: `var<storage, read_write> a: i32;`, |
| }, |
| write: { |
| keyword: `write`, |
| src: `var t: texture_storage_1d<rgba8unorm, write>;`, |
| }, |
| }; |
| |
| g.test('shadow_hides_access_mode') |
| .desc(`Test that shadows hide access modes.`) |
| .params(u => |
| u |
| .combine('inject', ['none', 'function', 'module'] as const) |
| .beginSubcases() |
| .combine('builtin', keysOf(kAccessModeTests)) |
| ) |
| .fn(t => { |
| const data = kAccessModeTests[t.params.builtin]; |
| const local = `let ${data.keyword} = 4;`; |
| |
| const module_shadow = t.params.inject === 'module' ? `var<private> ${data.keyword} : i32;` : ``; |
| const func = t.params.inject === 'function' ? local : ``; |
| |
| const code = ` |
| ${module_shadow} |
| |
| @group(0) @binding(0) ${data.src} |
| |
| @compute @workgroup_size(1) |
| fn main() { |
| ${func} |
| } |
| `; |
| |
| const pass = t.params.inject === 'none' || t.params.inject === 'function'; |
| t.expectCompileResult(pass, code); |
| }); |
