export const description = `Validation tests for diagnostic directive and attribute`;
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);
const kSpecDiagnosticRules = ['derivative_uniformity', 'subgroup_uniformity'];
const kSpecDiagnosticSeverities = ['off', 'info', 'warning', 'error'];
const kDiagnosticTypes = ['attribute', 'directive'];
const kBadSeverities = ['none', 'warn', 'goose', 'fatal', 'severe'];
const kBadSingleTokenRules = ['unknown', 'blahblahblah', 'derivative_uniform'];
function generateDiagnostic(type: string, severity: string, rule: string): string {
const diagnostic = `diagnostic(${severity}, ${rule})`;
if (type === 'directive') {
return diagnostic;
} else {
return '@' + diagnostic;
}
}
const kValidLocations = {
module: (diag: string) => `${diag};`,
function: (diag: string) => `${diag} fn foo() { }`,
compound: (diag: string) => `fn foo() { ${diag} { } }`,
if_stmt: (diag: string) => `fn foo() { ${diag} if true { } }`,
if_then: (diag: string) => `fn foo() { if true ${diag} { } }`,
if_else: (diag: string) => `fn foo() { if true { } else ${diag} { } }`,
switch_stmt: (diag: string) => `fn foo() { ${diag} switch 0 { default { } } }`,
switch_body: (diag: string) => `fn foo() { switch 0 ${diag} { default { } } }`,
switch_default: (diag: string) => `fn foo() { switch 0 { default ${diag} { } } }`,
switch_case: (diag: string) => `fn foo() { switch 0 { case 0 ${diag} { } default { } } }`,
loop_stmt: (diag: string) => `fn foo() { ${diag} loop { break; } }`,
loop_body: (diag: string) => `fn foo() { loop ${diag} { break; } }`,
loop_continuing: (diag: string) => `fn foo() { loop { continuing ${diag} { break if true; } } }`,
while_stmt: (diag: string) => `fn foo() { ${diag} while true { break; } }`,
while_body: (diag: string) => `fn foo() { while true ${diag} { break; } }`,
for_stmt: (diag: string) => `fn foo() { ${diag} for (var i = 0; i < 10; i++) { } }`,
for_body: (diag: string) => `fn foo() { for (var i = 0; i < 10; i++) ${diag} { } }`,
};
const kInvalidLocations = {
module_var: (diag: string) => `${diag} var<private> x : u32;`,
module_const: (diag: string) => `${diag} const x = 0;`,
module_override: (diag: string) => `${diag} override x : u32;`,
struct: (diag: string) => `${diag} struct S { x : u32 }`,
struct_member: (diag: string) => ` struct S { ${diag} x : u32 }`,
function_params: (diag: string) => `fn foo${diag}() { }`,
function_var: (diag: string) => `fn foo() { ${diag} var x = 0; }`,
function_let: (diag: string) => `fn foo() { ${diag} let x = 0; }`,
function_const: (diag: string) => `fn foo() { ${diag} const x = 0; }`,
pre_else: (diag: string) => `fn foo() { if true { } ${diag} else { } }`,
pre_default: (diag: string) => `fn foo() { switch 0 { ${diag} default { } } }`,
pre_case: (diag: string) => `fn foo() { switch 0 { ${diag} case 0 { } default { } } }`,
pre_continuing: (diag: string) => `fn foo() { loop { ${diag} continuing { break if true; } } }`,
pre_for_params: (diag: string) => `fn foo() { for ${diag} (var i = 0; i < 10; i++) { } }`,
};
const kNestedLocations = {
compound: (d1: string, d2: string) => `${d1} fn foo() { ${d2} { } }`,
if_stmt: (d1: string, d2: string) => `fn foo() { ${d1} if true ${d2} { } }`,
switch_stmt: (d1: string, d2: string) => `fn foo() { ${d1} switch 0 ${d2} { default { } } }`,
switch_body: (d1: string, d2: string) => `fn foo() { switch 0 ${d1} { default ${d2} { } } }`,
switch_case: (d1: string, d2: string) =>
`fn foo() { switch 0 { case 0 ${d1} { } default ${d2} { } } }`,
loop_stmt: (d1: string, d2: string) => `fn foo() { ${d1} loop ${d2} { break; } }`,
while_stmt: (d1: string, d2: string) => `fn foo() { ${d1} while true ${d2} { break; } }`,
for_stmt: (d1: string, d2: string) => `fn foo() { ${d1} for (var i = 0; i < 10; i++) ${d2} { } }`,
};
g.test('valid_params')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests required accepted diagnostic parameters`)
.params(u =>
u
.combine('severity', kSpecDiagnosticSeverities)
.combine('rule', kSpecDiagnosticRules)
.combine('type', kDiagnosticTypes)
)
.fn(t => {
const diag = generateDiagnostic(t.params.type, t.params.severity, t.params.rule);
let code = ``;
if (t.params.type === 'directive') {
code = kValidLocations['module'](diag);
} else {
code = kValidLocations['function'](diag);
}
t.expectCompileResult(true, code);
});
g.test('invalid_severity')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests invalid severities are rejected`)
.params(u => u.combine('severity', kBadSeverities).combine('type', kDiagnosticTypes))
.fn(t => {
const diag = generateDiagnostic(t.params.type, t.params.severity, 'derivative_uniformity');
let code = ``;
if (t.params.type === 'directive') {
code = kValidLocations['module'](diag);
} else {
code = kValidLocations['function'](diag);
}
t.expectCompileResult(false, code);
});
g.test('warning_unknown_rule')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests unknown single token rules issue a warning`)
.params(u => u.combine('type', kDiagnosticTypes).combine('rule', kBadSingleTokenRules))
.fn(t => {
const diag = generateDiagnostic(t.params.type, 'info', t.params.rule);
let code = ``;
if (t.params.type === 'directive') {
code = kValidLocations['module'](diag);
} else {
code = kValidLocations['function'](diag);
}
t.expectCompileWarning(true, code);
});
g.test('valid_locations')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests valid locations`)
.params(u =>
u
.combine('type', kDiagnosticTypes)
.combine('location', keysOf(kValidLocations))
.combine('rule', kSpecDiagnosticRules)
)
.fn(t => {
const diag = generateDiagnostic(t.params.type, 'info', t.params.rule);
const code = kValidLocations[t.params.location](diag);
let res = true;
if (t.params.type === 'directive') {
res = t.params.location === 'module';
} else {
res = t.params.location !== 'module';
}
if (res === false) {
t.expectCompileResult(true, kValidLocations[t.params.location](''));
}
t.expectCompileResult(res, code);
});
g.test('invalid_locations')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests invalid locations`)
.params(u =>
u
.combine('type', kDiagnosticTypes)
.combine('location', keysOf(kInvalidLocations))
.combine('rule', kSpecDiagnosticRules)
)
.fn(t => {
const diag = generateDiagnostic(t.params.type, 'info', t.params.rule);
t.expectCompileResult(true, kInvalidLocations[t.params.location](''));
t.expectCompileResult(false, kInvalidLocations[t.params.location](diag));
});
g.test('conflicting_directive')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests conflicts between directives`)
.params(u => u.combine('s1', kSpecDiagnosticSeverities).combine('s2', kSpecDiagnosticSeverities))
.fn(t => {
const d1 = generateDiagnostic('directive', t.params.s1, 'derivative_uniformity');
const d2 = generateDiagnostic('directive', t.params.s2, 'derivative_uniformity');
const code = `${kValidLocations['module'](d1)}\n${kValidLocations['module'](d2)}`;
t.expectCompileResult(t.params.s1 === t.params.s2, code);
});
g.test('duplicate_attribute_same_location')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests duplicate diagnostics at the same location must be on different rules`)
.params(u =>
u
.combine('loc', keysOf(kValidLocations))
.combine('same_rule', [true, false] as const)
.beginSubcases()
.combine('s1', kSpecDiagnosticSeverities)
.combine('s2', kSpecDiagnosticSeverities)
.filter(u => {
return u.loc !== 'module';
})
)
.fn(t => {
const rule1 = 'derivative_uniformity';
const rule2 = 'another_diagnostic_rule';
const d1 = generateDiagnostic('attribute', t.params.s1, rule1);
const d2 = generateDiagnostic('attribute', t.params.s2, t.params.same_rule ? rule1 : rule2);
const code = `${kValidLocations[t.params.loc](`${d1} ${d2}`)}`;
t.expectCompileResult(!t.params.same_rule, code);
});
g.test('conflicting_attribute_different_location')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests conflicts between attributes`)
.params(u =>
u
.combine('loc', keysOf(kNestedLocations))
.combine('s1', kSpecDiagnosticSeverities)
.combine('s2', kSpecDiagnosticSeverities)
.filter(u => {
return u.s1 !== u.s2;
})
)
.fn(t => {
const d1 = generateDiagnostic('attribute', t.params.s1, 'derivative_uniformity');
const d2 = generateDiagnostic('attribute', t.params.s2, 'derivative_uniformity');
const code = `${kNestedLocations[t.params.loc](d1, d2)}`;
t.expectCompileResult(true, code);
});
g.test('after_other_directives')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc(`Tests other global directives before a diagnostic directive.`)
.params(u =>
u.combine('directive', ['enable f16', 'requires readonly_and_readwrite_storage_textures'])
)
.fn(t => {
if (t.params.directive.startsWith('requires')) {
t.skipIfLanguageFeatureNotSupported('readonly_and_readwrite_storage_textures');
}
let code = `${t.params.directive};`;
code += generateDiagnostic('directive', 'info', 'derivative_uniformity') + ';';
t.expectCompileResult(true, code);
});
interface ScopeCase {
code: string;
result: boolean | 'warn';
}
function scopeCode(body: string): string {
return `
@group(0) @binding(0) var t : texture_1d<f32>;
@group(0) @binding(1) var s : sampler;
var<private> non_uniform_cond : bool;
var<private> non_uniform_coord : f32;
var<private> non_uniform_val : u32;
@fragment fn main() {
${body}
}
`;
}
const kScopeCases: Record<string, ScopeCase> = {
override_global_off: {
code: `
${generateDiagnostic('directive', 'error', 'derivative_uniformity')};
${scopeCode(`
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}`)};
`,
result: true,
},
override_global_on: {
code: `
${generateDiagnostic('directive', 'off', 'derivative_uniformity')};
${scopeCode(`
${generateDiagnostic('', 'error', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}`)}
`,
result: false,
},
override_global_warn: {
code: `
${generateDiagnostic('directive', 'error', 'derivative_uniformity')};
${scopeCode(`
${generateDiagnostic('', 'warning', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}`)}
`,
result: 'warn',
},
global_if_nothing_else_warn: {
code: `
${generateDiagnostic('directive', 'warning', 'derivative_uniformity')};
${scopeCode(`
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}`)}
`,
result: 'warn',
},
deepest_nesting_warn: {
code: scopeCode(`
${generateDiagnostic('', 'error', 'derivative_uniformity')}
if non_uniform_cond {
${generateDiagnostic('', 'warning', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}
}`),
result: 'warn',
},
deepest_nesting_off: {
code: scopeCode(`
${generateDiagnostic('', 'error', 'derivative_uniformity')}
if non_uniform_cond {
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}
}`),
result: true,
},
deepest_nesting_error: {
code: scopeCode(`
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
${generateDiagnostic('', 'error', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}
}`),
result: false,
},
other_nest_unaffected: {
code: `
${generateDiagnostic('directive', 'warning', 'derivative_uniformity')};
${scopeCode(`
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}
if non_uniform_cond {
_ = textureSample(t,s,0.0);
}`)}
`,
result: 'warn',
},
deeper_nest_no_effect: {
code: `
${generateDiagnostic('directive', 'error', 'derivative_uniformity')};
${scopeCode(`
if non_uniform_cond {
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
}
_ = textureSample(t,s,0.0);
}`)}
`,
result: false,
},
call_unaffected_error: {
code: `
${generateDiagnostic('directive', 'error', 'derivative_uniformity')};
fn foo() { _ = textureSample(t,s,0.0); }
${scopeCode(`
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
foo();
}`)}
`,
result: false,
},
call_unaffected_warn: {
code: `
${generateDiagnostic('directive', 'warning', 'derivative_uniformity')};
fn foo() { _ = textureSample(t,s,0.0); }
${scopeCode(`
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if non_uniform_cond {
foo();
}`)}
`,
result: 'warn',
},
call_unaffected_off: {
code: `
${generateDiagnostic('directive', 'off', 'derivative_uniformity')};
fn foo() { _ = textureSample(t,s,0.0); }
${scopeCode(`
${generateDiagnostic('', 'error', 'derivative_uniformity')}
if non_uniform_cond {
foo();
}`)}
`,
result: true,
},
if_condition_error: {
code: scopeCode(`
if (non_uniform_cond) {
${generateDiagnostic('', 'error', 'derivative_uniformity')}
if textureSample(t,s,non_uniform_coord).x > 0.0
${generateDiagnostic('', 'off', 'derivative_uniformity')} {
}
}`),
result: false,
},
if_condition_warn: {
code: scopeCode(`
if non_uniform_cond {
${generateDiagnostic('', 'warning', 'derivative_uniformity')}
if textureSample(t,s,non_uniform_coord).x > 0.0
${generateDiagnostic('', 'error', 'derivative_uniformity')} {
}
}`),
result: 'warn',
},
if_condition_off: {
code: scopeCode(`
if non_uniform_cond {
${generateDiagnostic('', 'off', 'derivative_uniformity')}
if textureSample(t,s,non_uniform_coord).x > 0.0
${generateDiagnostic('', 'error', 'derivative_uniformity')} {
}
}`),
result: true,
},
switch_error: {
code: scopeCode(`
${generateDiagnostic('', 'error', 'derivative_uniformity')}
switch non_uniform_val {
case 0 ${generateDiagnostic('', 'off', 'derivative_uniformity')} {
}
default {
_ = textureSample(t,s,0.0);
}
}`),
result: false,
},
switch_warn: {
code: scopeCode(`
${generateDiagnostic('', 'warning', 'derivative_uniformity')}
switch non_uniform_val {
case 0 ${generateDiagnostic('', 'off', 'derivative_uniformity')} {
}
default {
_ = textureSample(t,s,0.0);
}
}`),
result: 'warn',
},
switch_off: {
code: scopeCode(`
${generateDiagnostic('', 'off', 'derivative_uniformity')}
switch non_uniform_val {
case 0 ${generateDiagnostic('', 'error', 'derivative_uniformity')}{
}
default {
_ = textureSample(t,s,0.0);
}
}`),
result: true,
},
};
g.test('diagnostic_scoping')
.specURL('https://gpuweb.github.io/gpuweb/wgsl/#diagnostics')
.desc('Tests that innermost scope controls the diagnostic')
.params(u => u.combine('case', keysOf(kScopeCases)))
.fn(t => {
const testcase = kScopeCases[t.params.case];
if (testcase.result === 'warn') {
t.expectCompileWarning(true, testcase.code);
} else {
t.expectCompileResult(testcase.result as boolean, testcase.code);
}
});
