blob: 3fc00337a9ae0ef592d1267ae3844fc889c90071 [file] [log] [blame]
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/tint/transform/canonicalize_entry_point_io.h"
#include "src/tint/transform/test_helper.h"
#include "src/tint/transform/unshadow.h"
namespace tint::transform {
namespace {
using CanonicalizeEntryPointIOTest = TransformTest;
TEST_F(CanonicalizeEntryPointIOTest, Error_MissingTransformData) {
auto* src = "";
auto* expect =
"error: missing transform data for "
"tint::transform::CanonicalizeEntryPointIO";
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, NoShaderIO) {
// Test that we do not introduce wrapper functions when there is no shader IO
// to process.
auto* src = R"(
@fragment
fn frag_main() {
}
@compute @workgroup_size(1)
fn comp_main() {
}
)";
auto* expect = src;
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Parameters_Spirv) {
auto* src = R"(
@fragment
fn frag_main(@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
@builtin(position) coord : vec4<f32>) {
var col : f32 = (coord.x * loc1);
}
)";
auto* expect = R"(
@location(1) @internal(disable_validation__ignore_address_space) var<in> loc1_1 : f32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> loc2_1 : vec4<u32>;
@builtin(position) @internal(disable_validation__ignore_address_space) var<in> coord_1 : vec4<f32>;
fn frag_main_inner(loc1 : f32, loc2 : vec4<u32>, coord : vec4<f32>) {
var col : f32 = (coord.x * loc1);
}
@fragment
fn frag_main() {
frag_main_inner(loc1_1, loc2_1, coord_1);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Parameters_Msl) {
auto* src = R"(
@fragment
fn frag_main(@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
@builtin(position) coord : vec4<f32>) {
var col : f32 = (coord.x * loc1);
}
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(1)
loc1 : f32,
@location(2) @interpolate(flat)
loc2 : vec4<u32>,
}
fn frag_main_inner(loc1 : f32, loc2 : vec4<u32>, coord : vec4<f32>) {
var col : f32 = (coord.x * loc1);
}
@fragment
fn frag_main(@builtin(position) coord : vec4<f32>, tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc1, tint_symbol.loc2, coord);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Parameters_Hlsl) {
auto* src = R"(
@fragment
fn frag_main(@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
@builtin(position) coord : vec4<f32>) {
var col : f32 = (coord.x * loc1);
}
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(1)
loc1 : f32,
@location(2) @interpolate(flat)
loc2 : vec4<u32>,
@builtin(position)
coord : vec4<f32>,
}
fn frag_main_inner(loc1 : f32, loc2 : vec4<u32>, coord : vec4<f32>) {
var col : f32 = (coord.x * loc1);
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc1, tint_symbol.loc2, tint_symbol.coord);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Parameter_TypeAlias) {
auto* src = R"(
type myf32 = f32;
@fragment
fn frag_main(@location(1) loc1 : myf32) {
var x : myf32 = loc1;
}
)";
auto* expect = R"(
type myf32 = f32;
struct tint_symbol_1 {
@location(1)
loc1 : f32,
}
fn frag_main_inner(loc1 : myf32) {
var x : myf32 = loc1;
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc1);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Parameter_TypeAlias_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(@location(1) loc1 : myf32) {
var x : myf32 = loc1;
}
type myf32 = f32;
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(1)
loc1 : f32,
}
fn frag_main_inner(loc1 : myf32) {
var x : myf32 = loc1;
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc1);
}
type myf32 = f32;
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_Spirv) {
auto* src = R"(
struct FragBuiltins {
@builtin(position) coord : vec4<f32>,
};
struct FragLocations {
@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
};
@fragment
fn frag_main(@location(0) loc0 : f32,
locations : FragLocations,
builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
)";
auto* expect = R"(
@location(0) @internal(disable_validation__ignore_address_space) var<in> loc0_1 : f32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> loc1_1 : f32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> loc2_1 : vec4<u32>;
@builtin(position) @internal(disable_validation__ignore_address_space) var<in> coord_1 : vec4<f32>;
struct FragBuiltins {
coord : vec4<f32>,
}
struct FragLocations {
loc1 : f32,
loc2 : vec4<u32>,
}
fn frag_main_inner(loc0 : f32, locations : FragLocations, builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
@fragment
fn frag_main() {
frag_main_inner(loc0_1, FragLocations(loc1_1, loc2_1), FragBuiltins(coord_1));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_Spirv_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(@location(0) loc0 : f32,
locations : FragLocations,
builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
struct FragBuiltins {
@builtin(position) coord : vec4<f32>,
};
struct FragLocations {
@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
};
)";
auto* expect = R"(
@location(0) @internal(disable_validation__ignore_address_space) var<in> loc0_1 : f32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> loc1_1 : f32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> loc2_1 : vec4<u32>;
@builtin(position) @internal(disable_validation__ignore_address_space) var<in> coord_1 : vec4<f32>;
fn frag_main_inner(loc0 : f32, locations : FragLocations, builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
@fragment
fn frag_main() {
frag_main_inner(loc0_1, FragLocations(loc1_1, loc2_1), FragBuiltins(coord_1));
}
struct FragBuiltins {
coord : vec4<f32>,
}
struct FragLocations {
loc1 : f32,
loc2 : vec4<u32>,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_kMsl) {
auto* src = R"(
struct FragBuiltins {
@builtin(position) coord : vec4<f32>,
};
struct FragLocations {
@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
};
@fragment
fn frag_main(@location(0) loc0 : f32,
locations : FragLocations,
builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
)";
auto* expect = R"(
struct FragBuiltins {
coord : vec4<f32>,
}
struct FragLocations {
loc1 : f32,
loc2 : vec4<u32>,
}
struct tint_symbol_1 {
@location(0)
loc0 : f32,
@location(1)
loc1 : f32,
@location(2) @interpolate(flat)
loc2 : vec4<u32>,
}
fn frag_main_inner(loc0 : f32, locations : FragLocations, builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
@fragment
fn frag_main(@builtin(position) coord : vec4<f32>, tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc0, FragLocations(tint_symbol.loc1, tint_symbol.loc2), FragBuiltins(coord));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_kMsl_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(@location(0) loc0 : f32,
locations : FragLocations,
builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
struct FragBuiltins {
@builtin(position) coord : vec4<f32>,
};
struct FragLocations {
@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0)
loc0 : f32,
@location(1)
loc1 : f32,
@location(2) @interpolate(flat)
loc2 : vec4<u32>,
}
fn frag_main_inner(loc0 : f32, locations : FragLocations, builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
@fragment
fn frag_main(@builtin(position) coord : vec4<f32>, tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc0, FragLocations(tint_symbol.loc1, tint_symbol.loc2), FragBuiltins(coord));
}
struct FragBuiltins {
coord : vec4<f32>,
}
struct FragLocations {
loc1 : f32,
loc2 : vec4<u32>,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_Hlsl) {
auto* src = R"(
struct FragBuiltins {
@builtin(position) coord : vec4<f32>,
};
struct FragLocations {
@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
};
@fragment
fn frag_main(@location(0) loc0 : f32,
locations : FragLocations,
builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
)";
auto* expect = R"(
struct FragBuiltins {
coord : vec4<f32>,
}
struct FragLocations {
loc1 : f32,
loc2 : vec4<u32>,
}
struct tint_symbol_1 {
@location(0)
loc0 : f32,
@location(1)
loc1 : f32,
@location(2) @interpolate(flat)
loc2 : vec4<u32>,
@builtin(position)
coord : vec4<f32>,
}
fn frag_main_inner(loc0 : f32, locations : FragLocations, builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc0, FragLocations(tint_symbol.loc1, tint_symbol.loc2), FragBuiltins(tint_symbol.coord));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_Hlsl_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(@location(0) loc0 : f32,
locations : FragLocations,
builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
struct FragBuiltins {
@builtin(position) coord : vec4<f32>,
};
struct FragLocations {
@location(1) loc1 : f32,
@location(2) @interpolate(flat) loc2 : vec4<u32>,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0)
loc0 : f32,
@location(1)
loc1 : f32,
@location(2) @interpolate(flat)
loc2 : vec4<u32>,
@builtin(position)
coord : vec4<f32>,
}
fn frag_main_inner(loc0 : f32, locations : FragLocations, builtins : FragBuiltins) {
var col : f32 = ((builtins.coord.x * locations.loc1) + loc0);
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) {
frag_main_inner(tint_symbol.loc0, FragLocations(tint_symbol.loc1, tint_symbol.loc2), FragBuiltins(tint_symbol.coord));
}
struct FragBuiltins {
coord : vec4<f32>,
}
struct FragLocations {
loc1 : f32,
loc2 : vec4<u32>,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_NonStruct_Spirv) {
auto* src = R"(
@fragment
fn frag_main() -> @builtin(frag_depth) f32 {
return 1.0;
}
)";
auto* expect = R"(
@builtin(frag_depth) @internal(disable_validation__ignore_address_space) var<out> value : f32;
fn frag_main_inner() -> f32 {
return 1.0;
}
@fragment
fn frag_main() {
let inner_result = frag_main_inner();
value = inner_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_NonStruct_Msl) {
auto* src = R"(
@fragment
fn frag_main() -> @builtin(frag_depth) f32 {
return 1.0;
}
)";
auto* expect = R"(
struct tint_symbol {
@builtin(frag_depth)
value : f32,
}
fn frag_main_inner() -> f32 {
return 1.0;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.value = inner_result;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_NonStruct_Hlsl) {
auto* src = R"(
@fragment
fn frag_main() -> @builtin(frag_depth) f32 {
return 1.0;
}
)";
auto* expect = R"(
struct tint_symbol {
@builtin(frag_depth)
value : f32,
}
fn frag_main_inner() -> f32 {
return 1.0;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.value = inner_result;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_Struct_Spirv) {
auto* src = R"(
struct FragOutput {
@location(0) color : vec4<f32>,
@builtin(frag_depth) depth : f32,
@builtin(sample_mask) mask : u32,
};
@fragment
fn frag_main() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
)";
auto* expect = R"(
@location(0) @internal(disable_validation__ignore_address_space) var<out> color_1 : vec4<f32>;
@builtin(frag_depth) @internal(disable_validation__ignore_address_space) var<out> depth_1 : f32;
@builtin(sample_mask) @internal(disable_validation__ignore_address_space) var<out> mask_1 : array<u32, 1u>;
struct FragOutput {
color : vec4<f32>,
depth : f32,
mask : u32,
}
fn frag_main_inner() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
@fragment
fn frag_main() {
let inner_result = frag_main_inner();
color_1 = inner_result.color;
depth_1 = inner_result.depth;
mask_1[0i] = inner_result.mask;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_Struct_Spirv_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
struct FragOutput {
@location(0) color : vec4<f32>,
@builtin(frag_depth) depth : f32,
@builtin(sample_mask) mask : u32,
};
)";
auto* expect = R"(
@location(0) @internal(disable_validation__ignore_address_space) var<out> color_1 : vec4<f32>;
@builtin(frag_depth) @internal(disable_validation__ignore_address_space) var<out> depth_1 : f32;
@builtin(sample_mask) @internal(disable_validation__ignore_address_space) var<out> mask_1 : array<u32, 1u>;
fn frag_main_inner() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
@fragment
fn frag_main() {
let inner_result = frag_main_inner();
color_1 = inner_result.color;
depth_1 = inner_result.depth;
mask_1[0i] = inner_result.mask;
}
struct FragOutput {
color : vec4<f32>,
depth : f32,
mask : u32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_Struct_Msl) {
auto* src = R"(
struct FragOutput {
@location(0) color : vec4<f32>,
@builtin(frag_depth) depth : f32,
@builtin(sample_mask) mask : u32,
};
@fragment
fn frag_main() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
)";
auto* expect = R"(
struct FragOutput {
color : vec4<f32>,
depth : f32,
mask : u32,
}
struct tint_symbol {
@location(0)
color : vec4<f32>,
@builtin(frag_depth)
depth : f32,
@builtin(sample_mask)
mask : u32,
}
fn frag_main_inner() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.color = inner_result.color;
wrapper_result.depth = inner_result.depth;
wrapper_result.mask = inner_result.mask;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_Struct_Msl_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
struct FragOutput {
@location(0) color : vec4<f32>,
@builtin(frag_depth) depth : f32,
@builtin(sample_mask) mask : u32,
};
)";
auto* expect = R"(
struct tint_symbol {
@location(0)
color : vec4<f32>,
@builtin(frag_depth)
depth : f32,
@builtin(sample_mask)
mask : u32,
}
fn frag_main_inner() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.color = inner_result.color;
wrapper_result.depth = inner_result.depth;
wrapper_result.mask = inner_result.mask;
return wrapper_result;
}
struct FragOutput {
color : vec4<f32>,
depth : f32,
mask : u32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_Struct_Hlsl) {
auto* src = R"(
struct FragOutput {
@location(0) color : vec4<f32>,
@builtin(frag_depth) depth : f32,
@builtin(sample_mask) mask : u32,
};
@fragment
fn frag_main() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
)";
auto* expect = R"(
struct FragOutput {
color : vec4<f32>,
depth : f32,
mask : u32,
}
struct tint_symbol {
@location(0)
color : vec4<f32>,
@builtin(frag_depth)
depth : f32,
@builtin(sample_mask)
mask : u32,
}
fn frag_main_inner() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.color = inner_result.color;
wrapper_result.depth = inner_result.depth;
wrapper_result.mask = inner_result.mask;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Return_Struct_Hlsl_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
struct FragOutput {
@location(0) color : vec4<f32>,
@builtin(frag_depth) depth : f32,
@builtin(sample_mask) mask : u32,
};
)";
auto* expect = R"(
struct tint_symbol {
@location(0)
color : vec4<f32>,
@builtin(frag_depth)
depth : f32,
@builtin(sample_mask)
mask : u32,
}
fn frag_main_inner() -> FragOutput {
var output : FragOutput;
output.depth = 1.0;
output.mask = 7u;
output.color = vec4<f32>(0.5, 0.5, 0.5, 1.0);
return output;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.color = inner_result.color;
wrapper_result.depth = inner_result.depth;
wrapper_result.mask = inner_result.mask;
return wrapper_result;
}
struct FragOutput {
color : vec4<f32>,
depth : f32,
mask : u32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_SharedDeviceFunction_Spirv) {
auto* src = R"(
struct FragmentInput {
@location(0) value : f32,
@location(1) mul : f32,
};
fn foo(x : FragmentInput) -> f32 {
return x.value * x.mul;
}
@fragment
fn frag_main1(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
)";
auto* expect = R"(
@location(0) @internal(disable_validation__ignore_address_space) var<in> value_1 : f32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> mul_1 : f32;
@location(0) @internal(disable_validation__ignore_address_space) var<in> value_2 : f32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> mul_2 : f32;
struct FragmentInput {
value : f32,
mul : f32,
}
fn foo(x : FragmentInput) -> f32 {
return (x.value * x.mul);
}
fn frag_main1_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main1() {
frag_main1_inner(FragmentInput(value_1, mul_1));
}
fn frag_main2_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2() {
frag_main2_inner(FragmentInput(value_2, mul_2));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_SharedDeviceFunction_Spirv_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main1(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
fn foo(x : FragmentInput) -> f32 {
return x.value * x.mul;
}
struct FragmentInput {
@location(0) value : f32,
@location(1) mul : f32,
};
)";
auto* expect = R"(
@location(0) @internal(disable_validation__ignore_address_space) var<in> value_1 : f32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> mul_1 : f32;
@location(0) @internal(disable_validation__ignore_address_space) var<in> value_2 : f32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> mul_2 : f32;
fn frag_main1_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main1() {
frag_main1_inner(FragmentInput(value_1, mul_1));
}
fn frag_main2_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2() {
frag_main2_inner(FragmentInput(value_2, mul_2));
}
fn foo(x : FragmentInput) -> f32 {
return (x.value * x.mul);
}
struct FragmentInput {
value : f32,
mul : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_SharedDeviceFunction_Msl) {
auto* src = R"(
struct FragmentInput {
@location(0) value : f32,
@location(1) mul : f32,
};
fn foo(x : FragmentInput) -> f32 {
return x.value * x.mul;
}
@fragment
fn frag_main1(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
)";
auto* expect = R"(
struct FragmentInput {
value : f32,
mul : f32,
}
fn foo(x : FragmentInput) -> f32 {
return (x.value * x.mul);
}
struct tint_symbol_1 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main1_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main1(tint_symbol : tint_symbol_1) {
frag_main1_inner(FragmentInput(tint_symbol.value, tint_symbol.mul));
}
struct tint_symbol_3 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main2_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(tint_symbol_2 : tint_symbol_3) {
frag_main2_inner(FragmentInput(tint_symbol_2.value, tint_symbol_2.mul));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_SharedDeviceFunction_Msl_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main1(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
fn foo(x : FragmentInput) -> f32 {
return x.value * x.mul;
}
struct FragmentInput {
@location(0) value : f32,
@location(1) mul : f32,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main1_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main1(tint_symbol : tint_symbol_1) {
frag_main1_inner(FragmentInput(tint_symbol.value, tint_symbol.mul));
}
struct tint_symbol_3 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main2_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(tint_symbol_2 : tint_symbol_3) {
frag_main2_inner(FragmentInput(tint_symbol_2.value, tint_symbol_2.mul));
}
fn foo(x : FragmentInput) -> f32 {
return (x.value * x.mul);
}
struct FragmentInput {
value : f32,
mul : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_SharedDeviceFunction_Hlsl) {
auto* src = R"(
struct FragmentInput {
@location(0) value : f32,
@location(1) mul : f32,
};
fn foo(x : FragmentInput) -> f32 {
return x.value * x.mul;
}
@fragment
fn frag_main1(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
)";
auto* expect = R"(
struct FragmentInput {
value : f32,
mul : f32,
}
fn foo(x : FragmentInput) -> f32 {
return (x.value * x.mul);
}
struct tint_symbol_1 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main1_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main1(tint_symbol : tint_symbol_1) {
frag_main1_inner(FragmentInput(tint_symbol.value, tint_symbol.mul));
}
struct tint_symbol_3 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main2_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(tint_symbol_2 : tint_symbol_3) {
frag_main2_inner(FragmentInput(tint_symbol_2.value, tint_symbol_2.mul));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, StructParameters_SharedDeviceFunction_Hlsl_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main1(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
fn foo(x : FragmentInput) -> f32 {
return x.value * x.mul;
}
struct FragmentInput {
@location(0) value : f32,
@location(1) mul : f32,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main1_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main1(tint_symbol : tint_symbol_1) {
frag_main1_inner(FragmentInput(tint_symbol.value, tint_symbol.mul));
}
struct tint_symbol_3 {
@location(0)
value : f32,
@location(1)
mul : f32,
}
fn frag_main2_inner(inputs : FragmentInput) {
var x : f32 = foo(inputs);
}
@fragment
fn frag_main2(tint_symbol_2 : tint_symbol_3) {
frag_main2_inner(FragmentInput(tint_symbol_2.value, tint_symbol_2.mul));
}
fn foo(x : FragmentInput) -> f32 {
return (x.value * x.mul);
}
struct FragmentInput {
value : f32,
mul : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Struct_ModuleScopeVariable) {
auto* src = R"(
struct FragmentInput {
@location(0) col1 : f32,
@location(1) col2 : f32,
};
var<private> global_inputs : FragmentInput;
fn foo() -> f32 {
return global_inputs.col1 * 0.5;
}
fn bar() -> f32 {
return global_inputs.col2 * 2.0;
}
@fragment
fn frag_main1(inputs : FragmentInput) {
global_inputs = inputs;
var r : f32 = foo();
var g : f32 = bar();
}
)";
auto* expect = R"(
struct FragmentInput {
col1 : f32,
col2 : f32,
}
var<private> global_inputs : FragmentInput;
fn foo() -> f32 {
return (global_inputs.col1 * 0.5);
}
fn bar() -> f32 {
return (global_inputs.col2 * 2.0);
}
struct tint_symbol_1 {
@location(0)
col1 : f32,
@location(1)
col2 : f32,
}
fn frag_main1_inner(inputs : FragmentInput) {
global_inputs = inputs;
var r : f32 = foo();
var g : f32 = bar();
}
@fragment
fn frag_main1(tint_symbol : tint_symbol_1) {
frag_main1_inner(FragmentInput(tint_symbol.col1, tint_symbol.col2));
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Struct_ModuleScopeVariable_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main1(inputs : FragmentInput) {
global_inputs = inputs;
var r : f32 = foo();
var g : f32 = bar();
}
fn foo() -> f32 {
return global_inputs.col1 * 0.5;
}
fn bar() -> f32 {
return global_inputs.col2 * 2.0;
}
var<private> global_inputs : FragmentInput;
struct FragmentInput {
@location(0) col1 : f32,
@location(1) col2 : f32,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0)
col1 : f32,
@location(1)
col2 : f32,
}
fn frag_main1_inner(inputs : FragmentInput) {
global_inputs = inputs;
var r : f32 = foo();
var g : f32 = bar();
}
@fragment
fn frag_main1(tint_symbol : tint_symbol_1) {
frag_main1_inner(FragmentInput(tint_symbol.col1, tint_symbol.col2));
}
fn foo() -> f32 {
return (global_inputs.col1 * 0.5);
}
fn bar() -> f32 {
return (global_inputs.col2 * 2.0);
}
var<private> global_inputs : FragmentInput;
struct FragmentInput {
col1 : f32,
col2 : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Struct_TypeAliases) {
auto* src = R"(
type myf32 = f32;
struct FragmentInput {
@location(0) col1 : myf32,
@location(1) col2 : myf32,
};
struct FragmentOutput {
@location(0) col1 : myf32,
@location(1) col2 : myf32,
};
type MyFragmentInput = FragmentInput;
type MyFragmentOutput = FragmentOutput;
fn foo(x : MyFragmentInput) -> myf32 {
return x.col1;
}
@fragment
fn frag_main(inputs : MyFragmentInput) -> MyFragmentOutput {
var x : myf32 = foo(inputs);
return MyFragmentOutput(x, inputs.col2);
}
)";
auto* expect = R"(
type myf32 = f32;
struct FragmentInput {
col1 : myf32,
col2 : myf32,
}
struct FragmentOutput {
col1 : myf32,
col2 : myf32,
}
type MyFragmentInput = FragmentInput;
type MyFragmentOutput = FragmentOutput;
fn foo(x : MyFragmentInput) -> myf32 {
return x.col1;
}
struct tint_symbol_1 {
@location(0)
col1 : f32,
@location(1)
col2 : f32,
}
struct tint_symbol_2 {
@location(0)
col1 : f32,
@location(1)
col2 : f32,
}
fn frag_main_inner(inputs : MyFragmentInput) -> MyFragmentOutput {
var x : myf32 = foo(inputs);
return MyFragmentOutput(x, inputs.col2);
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) -> tint_symbol_2 {
let inner_result = frag_main_inner(MyFragmentInput(tint_symbol.col1, tint_symbol.col2));
var wrapper_result : tint_symbol_2;
wrapper_result.col1 = inner_result.col1;
wrapper_result.col2 = inner_result.col2;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Struct_TypeAliases_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(inputs : MyFragmentInput) -> MyFragmentOutput {
var x : myf32 = foo(inputs);
return MyFragmentOutput(x, inputs.col2);
}
type MyFragmentInput = FragmentInput;
type MyFragmentOutput = FragmentOutput;
fn foo(x : MyFragmentInput) -> myf32 {
return x.col1;
}
struct FragmentInput {
@location(0) col1 : myf32,
@location(1) col2 : myf32,
};
struct FragmentOutput {
@location(0) col1 : myf32,
@location(1) col2 : myf32,
};
type myf32 = f32;
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0)
col1 : f32,
@location(1)
col2 : f32,
}
struct tint_symbol_2 {
@location(0)
col1 : f32,
@location(1)
col2 : f32,
}
fn frag_main_inner(inputs : MyFragmentInput) -> MyFragmentOutput {
var x : myf32 = foo(inputs);
return MyFragmentOutput(x, inputs.col2);
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) -> tint_symbol_2 {
let inner_result = frag_main_inner(MyFragmentInput(tint_symbol.col1, tint_symbol.col2));
var wrapper_result : tint_symbol_2;
wrapper_result.col1 = inner_result.col1;
wrapper_result.col2 = inner_result.col2;
return wrapper_result;
}
type MyFragmentInput = FragmentInput;
type MyFragmentOutput = FragmentOutput;
fn foo(x : MyFragmentInput) -> myf32 {
return x.col1;
}
struct FragmentInput {
col1 : myf32,
col2 : myf32,
}
struct FragmentOutput {
col1 : myf32,
col2 : myf32,
}
type myf32 = f32;
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, InterpolateAttributes) {
auto* src = R"(
struct VertexOut {
@builtin(position) pos : vec4<f32>,
@location(1) @interpolate(flat) loc1 : f32,
@location(2) @interpolate(linear, sample) loc2 : f32,
@location(3) @interpolate(perspective, centroid) loc3 : f32,
};
struct FragmentIn {
@location(1) @interpolate(flat) loc1 : f32,
@location(2) @interpolate(linear, sample) loc2 : f32,
};
@vertex
fn vert_main() -> VertexOut {
return VertexOut();
}
@fragment
fn frag_main(inputs : FragmentIn,
@location(3) @interpolate(perspective, centroid) loc3 : f32) {
let x = inputs.loc1 + inputs.loc2 + loc3;
}
)";
auto* expect = R"(
struct VertexOut {
pos : vec4<f32>,
loc1 : f32,
loc2 : f32,
loc3 : f32,
}
struct FragmentIn {
loc1 : f32,
loc2 : f32,
}
struct tint_symbol {
@location(1) @interpolate(flat)
loc1 : f32,
@location(2) @interpolate(linear, sample)
loc2 : f32,
@location(3) @interpolate(perspective, centroid)
loc3 : f32,
@builtin(position)
pos : vec4<f32>,
}
fn vert_main_inner() -> VertexOut {
return VertexOut();
}
@vertex
fn vert_main() -> tint_symbol {
let inner_result = vert_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.pos = inner_result.pos;
wrapper_result.loc1 = inner_result.loc1;
wrapper_result.loc2 = inner_result.loc2;
wrapper_result.loc3 = inner_result.loc3;
return wrapper_result;
}
struct tint_symbol_2 {
@location(1) @interpolate(flat)
loc1 : f32,
@location(2) @interpolate(linear, sample)
loc2 : f32,
@location(3) @interpolate(perspective, centroid)
loc3 : f32,
}
fn frag_main_inner(inputs : FragmentIn, loc3 : f32) {
let x = ((inputs.loc1 + inputs.loc2) + loc3);
}
@fragment
fn frag_main(tint_symbol_1 : tint_symbol_2) {
frag_main_inner(FragmentIn(tint_symbol_1.loc1, tint_symbol_1.loc2), tint_symbol_1.loc3);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, InterpolateAttributes_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(inputs : FragmentIn,
@location(3) @interpolate(perspective, centroid) loc3 : f32) {
let x = inputs.loc1 + inputs.loc2 + loc3;
}
@vertex
fn vert_main() -> VertexOut {
return VertexOut();
}
struct VertexOut {
@builtin(position) pos : vec4<f32>,
@location(1) @interpolate(flat) loc1 : f32,
@location(2) @interpolate(linear, sample) loc2 : f32,
@location(3) @interpolate(perspective, centroid) loc3 : f32,
};
struct FragmentIn {
@location(1) @interpolate(flat) loc1: f32,
@location(2) @interpolate(linear, sample) loc2 : f32,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(1) @interpolate(flat)
loc1 : f32,
@location(2) @interpolate(linear, sample)
loc2 : f32,
@location(3) @interpolate(perspective, centroid)
loc3 : f32,
}
fn frag_main_inner(inputs : FragmentIn, loc3 : f32) {
let x = ((inputs.loc1 + inputs.loc2) + loc3);
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) {
frag_main_inner(FragmentIn(tint_symbol.loc1, tint_symbol.loc2), tint_symbol.loc3);
}
struct tint_symbol_2 {
@location(1) @interpolate(flat)
loc1 : f32,
@location(2) @interpolate(linear, sample)
loc2 : f32,
@location(3) @interpolate(perspective, centroid)
loc3 : f32,
@builtin(position)
pos : vec4<f32>,
}
fn vert_main_inner() -> VertexOut {
return VertexOut();
}
@vertex
fn vert_main() -> tint_symbol_2 {
let inner_result = vert_main_inner();
var wrapper_result : tint_symbol_2;
wrapper_result.pos = inner_result.pos;
wrapper_result.loc1 = inner_result.loc1;
wrapper_result.loc2 = inner_result.loc2;
wrapper_result.loc3 = inner_result.loc3;
return wrapper_result;
}
struct VertexOut {
pos : vec4<f32>,
loc1 : f32,
loc2 : f32,
loc3 : f32,
}
struct FragmentIn {
loc1 : f32,
loc2 : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, InterpolateAttributes_Integers_Spirv) {
// Test that we add a Flat attribute to integers that are vertex outputs and
// fragment inputs, but not vertex inputs or fragment outputs.
auto* src = R"(
struct VertexIn {
@location(0) i : i32,
@location(1) u : u32,
@location(2) vi : vec4<i32>,
@location(3) vu : vec4<u32>,
};
struct VertexOut {
@location(0) @interpolate(flat) i : i32,
@location(1) @interpolate(flat) u : u32,
@location(2) @interpolate(flat) vi : vec4<i32>,
@location(3) @interpolate(flat) vu : vec4<u32>,
@builtin(position) pos : vec4<f32>,
};
struct FragmentInterface {
@location(0) @interpolate(flat) i : i32,
@location(1) @interpolate(flat) u : u32,
@location(2) @interpolate(flat) vi : vec4<i32>,
@location(3) @interpolate(flat) vu : vec4<u32>,
};
@vertex
fn vert_main(in : VertexIn) -> VertexOut {
return VertexOut(in.i, in.u, in.vi, in.vu, vec4<f32>());
}
@fragment
fn frag_main(inputs : FragmentInterface) -> FragmentInterface {
return inputs;
}
)";
auto* expect =
R"(
@location(0) @internal(disable_validation__ignore_address_space) var<in> i_1 : i32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> u_1 : u32;
@location(2) @internal(disable_validation__ignore_address_space) var<in> vi_1 : vec4<i32>;
@location(3) @internal(disable_validation__ignore_address_space) var<in> vu_1 : vec4<u32>;
@location(0) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> i_2 : i32;
@location(1) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> u_2 : u32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> vi_2 : vec4<i32>;
@location(3) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> vu_2 : vec4<u32>;
@builtin(position) @internal(disable_validation__ignore_address_space) var<out> pos_1 : vec4<f32>;
@location(0) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> i_3 : i32;
@location(1) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> u_3 : u32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> vi_3 : vec4<i32>;
@location(3) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> vu_3 : vec4<u32>;
@location(0) @internal(disable_validation__ignore_address_space) var<out> i_4 : i32;
@location(1) @internal(disable_validation__ignore_address_space) var<out> u_4 : u32;
@location(2) @internal(disable_validation__ignore_address_space) var<out> vi_4 : vec4<i32>;
@location(3) @internal(disable_validation__ignore_address_space) var<out> vu_4 : vec4<u32>;
struct VertexIn {
i : i32,
u : u32,
vi : vec4<i32>,
vu : vec4<u32>,
}
struct VertexOut {
i : i32,
u : u32,
vi : vec4<i32>,
vu : vec4<u32>,
pos : vec4<f32>,
}
struct FragmentInterface {
i : i32,
u : u32,
vi : vec4<i32>,
vu : vec4<u32>,
}
fn vert_main_inner(in : VertexIn) -> VertexOut {
return VertexOut(in.i, in.u, in.vi, in.vu, vec4<f32>());
}
@vertex
fn vert_main() {
let inner_result = vert_main_inner(VertexIn(i_1, u_1, vi_1, vu_1));
i_2 = inner_result.i;
u_2 = inner_result.u;
vi_2 = inner_result.vi;
vu_2 = inner_result.vu;
pos_1 = inner_result.pos;
}
fn frag_main_inner(inputs : FragmentInterface) -> FragmentInterface {
return inputs;
}
@fragment
fn frag_main() {
let inner_result_1 = frag_main_inner(FragmentInterface(i_3, u_3, vi_3, vu_3));
i_4 = inner_result_1.i;
u_4 = inner_result_1.u;
vi_4 = inner_result_1.vi;
vu_4 = inner_result_1.vu;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, InterpolateAttributes_Integers_Spirv_OutOfOrder) {
// Test that we add a Flat attribute to integers that are vertex outputs and
// fragment inputs, but not vertex inputs or fragment outputs.
auto* src = R"(
@vertex
fn vert_main(in : VertexIn) -> VertexOut {
return VertexOut(in.i, in.u, in.vi, in.vu, vec4<f32>());
}
@fragment
fn frag_main(inputs : FragmentInterface) -> FragmentInterface {
return inputs;
}
struct VertexIn {
@location(0) i : i32,
@location(1) u : u32,
@location(2) vi : vec4<i32>,
@location(3) vu : vec4<u32>,
};
struct VertexOut {
@location(0) @interpolate(flat) i : i32,
@location(1) @interpolate(flat) u : u32,
@location(2) @interpolate(flat) vi : vec4<i32>,
@location(3) @interpolate(flat) vu : vec4<u32>,
@builtin(position) pos : vec4<f32>,
};
struct FragmentInterface {
@location(0) @interpolate(flat) i : i32,
@location(1) @interpolate(flat) u : u32,
@location(2) @interpolate(flat) vi : vec4<i32>,
@location(3) @interpolate(flat) vu : vec4<u32>,
};
)";
auto* expect =
R"(
@location(0) @internal(disable_validation__ignore_address_space) var<in> i_1 : i32;
@location(1) @internal(disable_validation__ignore_address_space) var<in> u_1 : u32;
@location(2) @internal(disable_validation__ignore_address_space) var<in> vi_1 : vec4<i32>;
@location(3) @internal(disable_validation__ignore_address_space) var<in> vu_1 : vec4<u32>;
@location(0) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> i_2 : i32;
@location(1) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> u_2 : u32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> vi_2 : vec4<i32>;
@location(3) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<out> vu_2 : vec4<u32>;
@builtin(position) @internal(disable_validation__ignore_address_space) var<out> pos_1 : vec4<f32>;
@location(0) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> i_3 : i32;
@location(1) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> u_3 : u32;
@location(2) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> vi_3 : vec4<i32>;
@location(3) @interpolate(flat) @internal(disable_validation__ignore_address_space) var<in> vu_3 : vec4<u32>;
@location(0) @internal(disable_validation__ignore_address_space) var<out> i_4 : i32;
@location(1) @internal(disable_validation__ignore_address_space) var<out> u_4 : u32;
@location(2) @internal(disable_validation__ignore_address_space) var<out> vi_4 : vec4<i32>;
@location(3) @internal(disable_validation__ignore_address_space) var<out> vu_4 : vec4<u32>;
fn vert_main_inner(in : VertexIn) -> VertexOut {
return VertexOut(in.i, in.u, in.vi, in.vu, vec4<f32>());
}
@vertex
fn vert_main() {
let inner_result = vert_main_inner(VertexIn(i_1, u_1, vi_1, vu_1));
i_2 = inner_result.i;
u_2 = inner_result.u;
vi_2 = inner_result.vi;
vu_2 = inner_result.vu;
pos_1 = inner_result.pos;
}
fn frag_main_inner(inputs : FragmentInterface) -> FragmentInterface {
return inputs;
}
@fragment
fn frag_main() {
let inner_result_1 = frag_main_inner(FragmentInterface(i_3, u_3, vi_3, vu_3));
i_4 = inner_result_1.i;
u_4 = inner_result_1.u;
vi_4 = inner_result_1.vi;
vu_4 = inner_result_1.vu;
}
struct VertexIn {
i : i32,
u : u32,
vi : vec4<i32>,
vu : vec4<u32>,
}
struct VertexOut {
i : i32,
u : u32,
vi : vec4<i32>,
vu : vec4<u32>,
pos : vec4<f32>,
}
struct FragmentInterface {
i : i32,
u : u32,
vi : vec4<i32>,
vu : vec4<u32>,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, InvariantAttributes) {
auto* src = R"(
struct VertexOut {
@builtin(position) @invariant pos : vec4<f32>,
};
@vertex
fn main1() -> VertexOut {
return VertexOut();
}
@vertex
fn main2() -> @builtin(position) @invariant vec4<f32> {
return vec4<f32>();
}
)";
auto* expect = R"(
struct VertexOut {
pos : vec4<f32>,
}
struct tint_symbol {
@builtin(position) @invariant
pos : vec4<f32>,
}
fn main1_inner() -> VertexOut {
return VertexOut();
}
@vertex
fn main1() -> tint_symbol {
let inner_result = main1_inner();
var wrapper_result : tint_symbol;
wrapper_result.pos = inner_result.pos;
return wrapper_result;
}
struct tint_symbol_1 {
@builtin(position) @invariant
value : vec4<f32>,
}
fn main2_inner() -> vec4<f32> {
return vec4<f32>();
}
@vertex
fn main2() -> tint_symbol_1 {
let inner_result_1 = main2_inner();
var wrapper_result_1 : tint_symbol_1;
wrapper_result_1.value = inner_result_1;
return wrapper_result_1;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, InvariantAttributes_OutOfOrder) {
auto* src = R"(
@vertex
fn main1() -> VertexOut {
return VertexOut();
}
@vertex
fn main2() -> @builtin(position) @invariant vec4<f32> {
return vec4<f32>();
}
struct VertexOut {
@builtin(position) @invariant pos : vec4<f32>,
};
)";
auto* expect = R"(
struct tint_symbol {
@builtin(position) @invariant
pos : vec4<f32>,
}
fn main1_inner() -> VertexOut {
return VertexOut();
}
@vertex
fn main1() -> tint_symbol {
let inner_result = main1_inner();
var wrapper_result : tint_symbol;
wrapper_result.pos = inner_result.pos;
return wrapper_result;
}
struct tint_symbol_1 {
@builtin(position) @invariant
value : vec4<f32>,
}
fn main2_inner() -> vec4<f32> {
return vec4<f32>();
}
@vertex
fn main2() -> tint_symbol_1 {
let inner_result_1 = main2_inner();
var wrapper_result_1 : tint_symbol_1;
wrapper_result_1.value = inner_result_1;
return wrapper_result_1;
}
struct VertexOut {
pos : vec4<f32>,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Struct_LayoutAttributes) {
auto* src = R"(
struct FragmentInput {
@size(16) @location(1) value : f32,
@builtin(position) @align(32) coord : vec4<f32>,
@location(0) @interpolate(linear, sample) @align(128) loc0 : f32,
};
struct FragmentOutput {
@size(16) @location(1) @interpolate(flat) value : f32,
};
@fragment
fn frag_main(inputs : FragmentInput) -> FragmentOutput {
return FragmentOutput(inputs.coord.x * inputs.value + inputs.loc0);
}
)";
auto* expect = R"(
struct FragmentInput {
@size(16)
value : f32,
@align(32)
coord : vec4<f32>,
@align(128)
loc0 : f32,
}
struct FragmentOutput {
@size(16)
value : f32,
}
struct tint_symbol_1 {
@location(0) @interpolate(linear, sample)
loc0 : f32,
@location(1)
value : f32,
@builtin(position)
coord : vec4<f32>,
}
struct tint_symbol_2 {
@location(1)
value : f32,
}
fn frag_main_inner(inputs : FragmentInput) -> FragmentOutput {
return FragmentOutput(((inputs.coord.x * inputs.value) + inputs.loc0));
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) -> tint_symbol_2 {
let inner_result = frag_main_inner(FragmentInput(tint_symbol.value, tint_symbol.coord, tint_symbol.loc0));
var wrapper_result : tint_symbol_2;
wrapper_result.value = inner_result.value;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, Struct_LayoutAttributes_OutOfOrder) {
auto* src = R"(
@fragment
fn frag_main(inputs : FragmentInput) -> FragmentOutput {
return FragmentOutput(inputs.coord.x * inputs.value + inputs.loc0);
}
struct FragmentInput {
@size(16) @location(1) value : f32,
@builtin(position) @align(32) coord : vec4<f32>,
@location(0) @interpolate(linear, sample) @align(128) loc0 : f32,
};
struct FragmentOutput {
@size(16) @location(1) @interpolate(flat) value : f32,
};
)";
auto* expect = R"(
struct tint_symbol_1 {
@location(0) @interpolate(linear, sample)
loc0 : f32,
@location(1)
value : f32,
@builtin(position)
coord : vec4<f32>,
}
struct tint_symbol_2 {
@location(1)
value : f32,
}
fn frag_main_inner(inputs : FragmentInput) -> FragmentOutput {
return FragmentOutput(((inputs.coord.x * inputs.value) + inputs.loc0));
}
@fragment
fn frag_main(tint_symbol : tint_symbol_1) -> tint_symbol_2 {
let inner_result = frag_main_inner(FragmentInput(tint_symbol.value, tint_symbol.coord, tint_symbol.loc0));
var wrapper_result : tint_symbol_2;
wrapper_result.value = inner_result.value;
return wrapper_result;
}
struct FragmentInput {
@size(16)
value : f32,
@align(32)
coord : vec4<f32>,
@align(128)
loc0 : f32,
}
struct FragmentOutput {
@size(16)
value : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, SortedMembers) {
auto* src = R"(
struct VertexOutput {
@location(1) @interpolate(flat) b : u32,
@builtin(position) pos : vec4<f32>,
@location(3) @interpolate(flat) d : u32,
@location(0) a : f32,
@location(2) @interpolate(flat) c : i32,
};
struct FragmentInputExtra {
@location(3) @interpolate(flat) d : u32,
@builtin(position) pos : vec4<f32>,
@location(0) a : f32,
};
@vertex
fn vert_main() -> VertexOutput {
return VertexOutput();
}
@fragment
fn frag_main(@builtin(front_facing) ff : bool,
@location(2) @interpolate(flat) c : i32,
inputs : FragmentInputExtra,
@location(1) @interpolate(flat) b : u32) {
}
)";
auto* expect = R"(
struct VertexOutput {
b : u32,
pos : vec4<f32>,
d : u32,
a : f32,
c : i32,
}
struct FragmentInputExtra {
d : u32,
pos : vec4<f32>,
a : f32,
}
struct tint_symbol {
@location(0)
a : f32,
@location(1) @interpolate(flat)
b : u32,
@location(2) @interpolate(flat)
c : i32,
@location(3) @interpolate(flat)
d : u32,
@builtin(position)
pos : vec4<f32>,
}
fn vert_main_inner() -> VertexOutput {
return VertexOutput();
}
@vertex
fn vert_main() -> tint_symbol {
let inner_result = vert_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.b = inner_result.b;
wrapper_result.pos = inner_result.pos;
wrapper_result.d = inner_result.d;
wrapper_result.a = inner_result.a;
wrapper_result.c = inner_result.c;
return wrapper_result;
}
struct tint_symbol_2 {
@location(0)
a : f32,
@location(1) @interpolate(flat)
b : u32,
@location(2) @interpolate(flat)
c : i32,
@location(3) @interpolate(flat)
d : u32,
@builtin(position)
pos : vec4<f32>,
@builtin(front_facing)
ff : bool,
}
fn frag_main_inner(ff : bool, c : i32, inputs : FragmentInputExtra, b : u32) {
}
@fragment
fn frag_main(tint_symbol_1 : tint_symbol_2) {
frag_main_inner(tint_symbol_1.ff, tint_symbol_1.c, FragmentInputExtra(tint_symbol_1.d, tint_symbol_1.pos, tint_symbol_1.a), tint_symbol_1.b);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, SortedMembers_OutOfOrder) {
auto* src = R"(
@vertex
fn vert_main() -> VertexOutput {
return VertexOutput();
}
@fragment
fn frag_main(@builtin(front_facing) ff : bool,
@location(2) @interpolate(flat) c : i32,
inputs : FragmentInputExtra,
@location(1) @interpolate(flat) b : u32) {
}
struct VertexOutput {
@location(1) @interpolate(flat) b : u32,
@builtin(position) pos : vec4<f32>,
@location(3) @interpolate(flat) d : u32,
@location(0) a : f32,
@location(2) @interpolate(flat) c : i32,
};
struct FragmentInputExtra {
@location(3) @interpolate(flat) d : u32,
@builtin(position) pos : vec4<f32>,
@location(0) a : f32,
};
)";
auto* expect = R"(
struct tint_symbol {
@location(0)
a : f32,
@location(1) @interpolate(flat)
b : u32,
@location(2) @interpolate(flat)
c : i32,
@location(3) @interpolate(flat)
d : u32,
@builtin(position)
pos : vec4<f32>,
}
fn vert_main_inner() -> VertexOutput {
return VertexOutput();
}
@vertex
fn vert_main() -> tint_symbol {
let inner_result = vert_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.b = inner_result.b;
wrapper_result.pos = inner_result.pos;
wrapper_result.d = inner_result.d;
wrapper_result.a = inner_result.a;
wrapper_result.c = inner_result.c;
return wrapper_result;
}
struct tint_symbol_2 {
@location(0)
a : f32,
@location(1) @interpolate(flat)
b : u32,
@location(2) @interpolate(flat)
c : i32,
@location(3) @interpolate(flat)
d : u32,
@builtin(position)
pos : vec4<f32>,
@builtin(front_facing)
ff : bool,
}
fn frag_main_inner(ff : bool, c : i32, inputs : FragmentInputExtra, b : u32) {
}
@fragment
fn frag_main(tint_symbol_1 : tint_symbol_2) {
frag_main_inner(tint_symbol_1.ff, tint_symbol_1.c, FragmentInputExtra(tint_symbol_1.d, tint_symbol_1.pos, tint_symbol_1.a), tint_symbol_1.b);
}
struct VertexOutput {
b : u32,
pos : vec4<f32>,
d : u32,
a : f32,
c : i32,
}
struct FragmentInputExtra {
d : u32,
pos : vec4<f32>,
a : f32,
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, DontRenameSymbols) {
auto* src = R"(
@fragment
fn tint_symbol_1(@location(0) col : f32) {
}
)";
auto* expect = R"(
struct tint_symbol_2 {
@location(0)
col : f32,
}
fn tint_symbol_1_inner(col : f32) {
}
@fragment
fn tint_symbol_1(tint_symbol : tint_symbol_2) {
tint_symbol_1_inner(tint_symbol.col);
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, FixedSampleMask_VoidNoReturn) {
auto* src = R"(
@fragment
fn frag_main() {
}
)";
auto* expect = R"(
struct tint_symbol {
@builtin(sample_mask)
fixed_sample_mask : u32,
}
fn frag_main_inner() {
}
@fragment
fn frag_main() -> tint_symbol {
frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.fixed_sample_mask = 3u;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl, 0x03u);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, FixedSampleMask_VoidWithReturn) {
auto* src = R"(
@fragment
fn frag_main() {
return;
}
)";
auto* expect = R"(
struct tint_symbol {
@builtin(sample_mask)
fixed_sample_mask : u32,
}
fn frag_main_inner() {
return;
}
@fragment
fn frag_main() -> tint_symbol {
frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.fixed_sample_mask = 3u;
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl, 0x03u);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, FixedSampleMask_WithAuthoredMask) {
auto* src = R"(
@fragment
fn frag_main() -> @builtin(sample_mask) u32 {
return 7u;
}
)";
auto* expect = R"(
struct tint_symbol {
@builtin(sample_mask)
value : u32,
}
fn frag_main_inner() -> u32 {
return 7u;
}
@fragment
fn frag_main() -> tint_symbol {
let inner_result = frag_main_inner();
var wrapper_result : tint_symbol;
wrapper_result.value = (inner_result & 3u);
return wrapper_result;
}
)";
DataMap data;
data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kMsl, 0x03u);
auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
EXPECT_EQ(expect, str(got));
}
TEST_F(CanonicalizeEntryPointIOTest, FixedSampleMask_WithoutAuthoredMask) {
auto* src = R"(
@fragment
fn frag_main() -> @location(0) f32 {
return 1.0;
}
)";
auto* expect = R"(
struct tint_symbol {
@location(0)
value : f32,
@builtin(sample_mask)
fixed_sample_mask : u32,