Merge RenameReservedKeywords into the Renamer

Adds additional modes to the Renamer for renaming just HLSL or MSL
keywords. The sanitizers no longer rename reserved keywords
automatically, which isn't usually necessary anyway since Dawn renames
all symbols.

The tint executable automatically renames reserved keywords when
targeting HLSL and MSL. It now also has an option to rename
everything, which is useful for testing the renamer.

Change-Id: Idbfd53226805e851050024402be8d8f251b88707
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/47960
Commit-Queue: Ben Clayton <bclayton@chromium.org>
Auto-Submit: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@chromium.org>
This commit is contained in:
James Price 2021-04-16 08:28:54 +00:00 committed by Commit Bot service account
parent fc03a46516
commit fd7251bb02
15 changed files with 1893 additions and 2013 deletions

View File

@ -85,6 +85,7 @@ const char kUsage[] = R"(Usage: tint [options] <input-file>
bound_array_accessors bound_array_accessors
emit_vertex_point_size emit_vertex_point_size
first_index_offset first_index_offset
renamer
--parse-only -- Stop after parsing the input --parse-only -- Stop after parsing the input
--dump-ast -- Dump the generated AST to stdout --dump-ast -- Dump the generated AST to stdout
--dawn-validation -- SPIRV outputs are validated with the same flags --dawn-validation -- SPIRV outputs are validated with the same flags
@ -688,6 +689,8 @@ int main(int argc, const char** argv) {
} else if (name == "first_index_offset") { } else if (name == "first_index_offset") {
transform_manager.append( transform_manager.append(
std::make_unique<tint::transform::FirstIndexOffset>(0, 0)); std::make_unique<tint::transform::FirstIndexOffset>(0, 0));
} else if (name == "renamer") {
transform_manager.append(std::make_unique<tint::transform::Renamer>());
} else { } else {
std::cerr << "Unknown transform name: " << name << std::endl; std::cerr << "Unknown transform name: " << name << std::endl;
return 1; return 1;
@ -702,14 +705,24 @@ int main(int argc, const char** argv) {
break; break;
#endif // TINT_BUILD_SPV_WRITER #endif // TINT_BUILD_SPV_WRITER
#if TINT_BUILD_MSL_WRITER #if TINT_BUILD_MSL_WRITER
case Format::kMsl: case Format::kMsl: {
tint::transform::Renamer::Config renamer_config{
tint::transform::Renamer::Target::kMslKeywords};
transform_manager.append(
std::make_unique<tint::transform::Renamer>(renamer_config));
transform_manager.append(std::make_unique<tint::transform::Msl>()); transform_manager.append(std::make_unique<tint::transform::Msl>());
break; break;
}
#endif // TINT_BUILD_MSL_WRITER #endif // TINT_BUILD_MSL_WRITER
#if TINT_BUILD_HLSL_WRITER #if TINT_BUILD_HLSL_WRITER
case Format::kHlsl: case Format::kHlsl: {
tint::transform::Renamer::Config renamer_config{
tint::transform::Renamer::Target::kHlslKeywords};
transform_manager.append(
std::make_unique<tint::transform::Renamer>(renamer_config));
transform_manager.append(std::make_unique<tint::transform::Hlsl>()); transform_manager.append(std::make_unique<tint::transform::Hlsl>());
break; break;
}
#endif // TINT_BUILD_HLSL_WRITER #endif // TINT_BUILD_HLSL_WRITER
default: default:
break; break;

View File

@ -30,575 +30,6 @@
namespace tint { namespace tint {
namespace transform { namespace transform {
namespace {
// This list is used for a binary search and must be kept in sorted order.
const char* kReservedKeywords[] = {"AddressU",
"AddressV",
"AddressW",
"AllMemoryBarrier",
"AllMemoryBarrierWithGroupSync",
"AppendStructuredBuffer",
"BINORMAL",
"BLENDINDICES",
"BLENDWEIGHT",
"BlendState",
"BorderColor",
"Buffer",
"ByteAddressBuffer",
"COLOR",
"CheckAccessFullyMapped",
"ComparisonFunc",
"CompileShader",
"ComputeShader",
"ConsumeStructuredBuffer",
"D3DCOLORtoUBYTE4",
"DEPTH",
"DepthStencilState",
"DepthStencilView",
"DeviceMemoryBarrier",
"DeviceMemroyBarrierWithGroupSync",
"DomainShader",
"EvaluateAttributeAtCentroid",
"EvaluateAttributeAtSample",
"EvaluateAttributeSnapped",
"FOG",
"Filter",
"GeometryShader",
"GetRenderTargetSampleCount",
"GetRenderTargetSamplePosition",
"GroupMemoryBarrier",
"GroupMemroyBarrierWithGroupSync",
"Hullshader",
"InputPatch",
"InterlockedAdd",
"InterlockedAnd",
"InterlockedCompareExchange",
"InterlockedCompareStore",
"InterlockedExchange",
"InterlockedMax",
"InterlockedMin",
"InterlockedOr",
"InterlockedXor",
"LineStream",
"MaxAnisotropy",
"MaxLOD",
"MinLOD",
"MipLODBias",
"NORMAL",
"NULL",
"Normal",
"OutputPatch",
"POSITION",
"POSITIONT",
"PSIZE",
"PixelShader",
"PointStream",
"Process2DQuadTessFactorsAvg",
"Process2DQuadTessFactorsMax",
"Process2DQuadTessFactorsMin",
"ProcessIsolineTessFactors",
"ProcessQuadTessFactorsAvg",
"ProcessQuadTessFactorsMax",
"ProcessQuadTessFactorsMin",
"ProcessTriTessFactorsAvg",
"ProcessTriTessFactorsMax",
"ProcessTriTessFactorsMin",
"RWBuffer",
"RWByteAddressBuffer",
"RWStructuredBuffer",
"RWTexture1D",
"RWTexture2D",
"RWTexture2DArray",
"RWTexture3D",
"RasterizerState",
"RenderTargetView",
"SV_ClipDistance",
"SV_Coverage",
"SV_CullDistance",
"SV_Depth",
"SV_DepthGreaterEqual",
"SV_DepthLessEqual",
"SV_DispatchThreadID",
"SV_DomainLocation",
"SV_GSInstanceID",
"SV_GroupID",
"SV_GroupIndex",
"SV_GroupThreadID",
"SV_InnerCoverage",
"SV_InsideTessFactor",
"SV_InstanceID",
"SV_IsFrontFace",
"SV_OutputControlPointID",
"SV_Position",
"SV_PrimitiveID",
"SV_RenderTargetArrayIndex",
"SV_SampleIndex",
"SV_StencilRef",
"SV_Target",
"SV_TessFactor",
"SV_VertexArrayIndex",
"SV_VertexID",
"Sampler",
"Sampler1D",
"Sampler2D",
"Sampler3D",
"SamplerCUBE",
"StructuredBuffer",
"TANGENT",
"TESSFACTOR",
"TEXCOORD",
"Texcoord",
"Texture",
"Texture1D",
"Texture2D",
"Texture2DArray",
"Texture2DMS",
"Texture2DMSArray",
"Texture3D",
"TextureCube",
"TextureCubeArray",
"TriangleStream",
"VFACE",
"VPOS",
"VertexShader",
"abort",
"allow_uav_condition",
"asdouble",
"asfloat",
"asint",
"asm",
"asm_fragment",
"asuint",
"auto",
"bool",
"bool1",
"bool1x1",
"bool1x2",
"bool1x3",
"bool1x4",
"bool2",
"bool2x1",
"bool2x2",
"bool2x3",
"bool2x4",
"bool3",
"bool3x1",
"bool3x2",
"bool3x3",
"bool3x4",
"bool4",
"bool4x1",
"bool4x2",
"bool4x3",
"bool4x4",
"branch",
"break",
"call",
"case",
"catch",
"cbuffer",
"centroid",
"char",
"class",
"clip",
"column_major",
"compile_fragment",
"const",
"const_cast",
"continue",
"countbits",
"ddx",
"ddx_coarse",
"ddx_fine",
"ddy",
"ddy_coarse",
"ddy_fine",
"degrees",
"delete",
"discard",
"do",
"double",
"double1",
"double1x1",
"double1x2",
"double1x3",
"double1x4",
"double2",
"double2x1",
"double2x2",
"double2x3",
"double2x4",
"double3",
"double3x1",
"double3x2",
"double3x3",
"double3x4",
"double4",
"double4x1",
"double4x2",
"double4x3",
"double4x4",
"dst",
"dword",
"dword1",
"dword1x1",
"dword1x2",
"dword1x3",
"dword1x4",
"dword2",
"dword2x1",
"dword2x2",
"dword2x3",
"dword2x4",
"dword3",
"dword3x1",
"dword3x2",
"dword3x3",
"dword3x4",
"dword4",
"dword4x1",
"dword4x2",
"dword4x3",
"dword4x4",
"dynamic_cast",
"else",
"enum",
"errorf",
"explicit",
"export",
"extern",
"f16to32",
"f32tof16",
"false",
"fastopt",
"firstbithigh",
"firstbitlow",
"flatten",
"float",
"float1",
"float1x1",
"float1x2",
"float1x3",
"float1x4",
"float2",
"float2x1",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x1",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x1",
"float4x2",
"float4x3",
"float4x4",
"fmod",
"for",
"forcecase",
"frac",
"friend",
"fxgroup",
"goto",
"groupshared",
"half",
"half1",
"half1x1",
"half1x2",
"half1x3",
"half1x4",
"half2",
"half2x1",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x1",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x1",
"half4x2",
"half4x3",
"half4x4",
"if",
"in",
"inline",
"inout",
"int",
"int1",
"int1x1",
"int1x2",
"int1x3",
"int1x4",
"int2",
"int2x1",
"int2x2",
"int2x3",
"int2x4",
"int3",
"int3x1",
"int3x2",
"int3x3",
"int3x4",
"int4",
"int4x1",
"int4x2",
"int4x3",
"int4x4",
"interface",
"isfinite",
"isinf",
"isnan",
"lerp",
"lineadj",
"linear",
"lit",
"log10",
"long",
"loop",
"mad",
"matrix",
"min10float",
"min10float1",
"min10float1x1",
"min10float1x2",
"min10float1x3",
"min10float1x4",
"min10float2",
"min10float2x1",
"min10float2x2",
"min10float2x3",
"min10float2x4",
"min10float3",
"min10float3x1",
"min10float3x2",
"min10float3x3",
"min10float3x4",
"min10float4",
"min10float4x1",
"min10float4x2",
"min10float4x3",
"min10float4x4",
"min12int",
"min12int1",
"min12int1x1",
"min12int1x2",
"min12int1x3",
"min12int1x4",
"min12int2",
"min12int2x1",
"min12int2x2",
"min12int2x3",
"min12int2x4",
"min12int3",
"min12int3x1",
"min12int3x2",
"min12int3x3",
"min12int3x4",
"min12int4",
"min12int4x1",
"min12int4x2",
"min12int4x3",
"min12int4x4",
"min16float",
"min16float1",
"min16float1x1",
"min16float1x2",
"min16float1x3",
"min16float1x4",
"min16float2",
"min16float2x1",
"min16float2x2",
"min16float2x3",
"min16float2x4",
"min16float3",
"min16float3x1",
"min16float3x2",
"min16float3x3",
"min16float3x4",
"min16float4",
"min16float4x1",
"min16float4x2",
"min16float4x3",
"min16float4x4",
"min16int",
"min16int1",
"min16int1x1",
"min16int1x2",
"min16int1x3",
"min16int1x4",
"min16int2",
"min16int2x1",
"min16int2x2",
"min16int2x3",
"min16int2x4",
"min16int3",
"min16int3x1",
"min16int3x2",
"min16int3x3",
"min16int3x4",
"min16int4",
"min16int4x1",
"min16int4x2",
"min16int4x3",
"min16int4x4",
"min16uint",
"min16uint1",
"min16uint1x1",
"min16uint1x2",
"min16uint1x3",
"min16uint1x4",
"min16uint2",
"min16uint2x1",
"min16uint2x2",
"min16uint2x3",
"min16uint2x4",
"min16uint3",
"min16uint3x1",
"min16uint3x2",
"min16uint3x3",
"min16uint3x4",
"min16uint4",
"min16uint4x1",
"min16uint4x2",
"min16uint4x3",
"min16uint4x4",
"msad4",
"mul",
"mutable",
"namespace",
"new",
"nointerpolation",
"noise",
"noperspective",
"numthreads",
"operator",
"out",
"packoffset",
"pass",
"pixelfragment",
"pixelshader",
"point",
"precise",
"printf",
"private",
"protected",
"public",
"radians",
"rcp",
"refract",
"register",
"reinterpret_cast",
"return",
"row_major",
"rsqrt",
"sample",
"sampler",
"sampler1D",
"sampler2D",
"sampler3D",
"samplerCUBE",
"sampler_state",
"saturate",
"shared",
"short",
"signed",
"sincos",
"sizeof",
"snorm",
"stateblock",
"stateblock_state",
"static",
"static_cast",
"string",
"struct",
"switch",
"tbuffer",
"technique",
"technique10",
"technique11",
"template",
"tex1D",
"tex1Dbias",
"tex1Dgrad",
"tex1Dlod",
"tex1Dproj",
"tex2D",
"tex2Dbias",
"tex2Dgrad",
"tex2Dlod",
"tex2Dproj",
"tex3D",
"tex3Dbias",
"tex3Dgrad",
"tex3Dlod",
"tex3Dproj",
"texCUBE",
"texCUBEbias",
"texCUBEgrad",
"texCUBElod",
"texCUBEproj",
"texture",
"texture1D",
"texture1DArray",
"texture2D",
"texture2DArray",
"texture2DMS",
"texture2DMSArray",
"texture3D",
"textureCube",
"textureCubeArray",
"this",
"throw",
"transpose",
"triangle",
"triangleadj",
"true",
"try",
"typedef",
"typename",
"uint",
"uint1",
"uint1x1",
"uint1x2",
"uint1x3",
"uint1x4",
"uint2",
"uint2x1",
"uint2x2",
"uint2x3",
"uint2x4",
"uint3",
"uint3x1",
"uint3x2",
"uint3x3",
"uint3x4",
"uint4",
"uint4x1",
"uint4x2",
"uint4x3",
"uint4x4",
"uniform",
"union",
"unorm",
"unroll",
"unsigned",
"using",
"vector",
"vertexfragment",
"vertexshader",
"virtual",
"void",
"volatile",
"while"};
} // namespace
Hlsl::Hlsl() = default; Hlsl::Hlsl() = default;
Hlsl::~Hlsl() = default; Hlsl::~Hlsl() = default;
@ -616,7 +47,6 @@ Transform::Output Hlsl::Run(const Program* in, const DataMap& data) {
CloneContext ctx(&builder, &out.program); CloneContext ctx(&builder, &out.program);
PromoteInitializersToConstVar(ctx); PromoteInitializersToConstVar(ctx);
AddEmptyEntryPoint(ctx); AddEmptyEntryPoint(ctx);
RenameReservedKeywords(&ctx, kReservedKeywords);
ctx.Clone(); ctx.Clone();
return Output{Program(std::move(builder))}; return Output{Program(std::move(builder))};
} }

View File

@ -14,8 +14,6 @@
#include "src/transform/hlsl.h" #include "src/transform/hlsl.h"
#include <string>
#include "src/transform/test_helper.h" #include "src/transform/test_helper.h"
namespace tint { namespace tint {
@ -291,686 +289,8 @@ fn tint_unused_entry_point() {
auto got = Run<Hlsl>(src); auto got = Run<Hlsl>(src);
EXPECT_EQ(expect, str(got)); EXPECT_EQ(expect, str(got));
} }
using HlslReservedKeywordTest = TransformTestWithParam<std::string>;
TEST_P(HlslReservedKeywordTest, Keywords) {
auto keyword = GetParam();
auto src = R"(
[[stage(fragment)]]
fn main() {
var )" + keyword +
R"( : i32;
}
)";
auto expect = R"(
[[stage(fragment)]]
fn main() {
var tint_)" + keyword +
R"( : i32;
}
)";
auto got = Run<Hlsl>(src);
EXPECT_EQ(expect, str(got));
}
TEST_P(HlslReservedKeywordTest, AttemptSymbolCollision) {
auto keyword = GetParam();
auto src = R"(
[[stage(fragment)]]
fn main() {
var tint_)" +
keyword +
R"( : i32;
var tint_)" +
keyword +
R"(_1 : i32;
var )" + keyword +
R"( : i32;
var tint_)" +
keyword +
R"(_2 : i32;
var tint_)" +
keyword +
R"(_3 : i32;
}
)";
auto expect = R"(
[[stage(fragment)]]
fn main() {
var tint_)" + keyword +
R"( : i32;
var tint_)" + keyword +
R"(_1 : i32;
var tint_)" + keyword +
R"(_2 : i32;
var tint_)" + keyword +
R"(_2_1 : i32;
var tint_)" + keyword +
R"(_3 : i32;
}
)";
auto got = Run<Hlsl>(src);
EXPECT_EQ(expect, str(got));
}
INSTANTIATE_TEST_SUITE_P(HlslReservedKeywordTest,
HlslReservedKeywordTest,
testing::Values("AddressU",
"AddressV",
"AddressW",
"AllMemoryBarrier",
"AllMemoryBarrierWithGroupSync",
"AppendStructuredBuffer",
"BINORMAL",
"BLENDINDICES",
"BLENDWEIGHT",
"BlendState",
"BorderColor",
"Buffer",
"ByteAddressBuffer",
"COLOR",
"CheckAccessFullyMapped",
"ComparisonFunc",
"CompileShader",
"ComputeShader",
"ConsumeStructuredBuffer",
"D3DCOLORtoUBYTE4",
"DEPTH",
"DepthStencilState",
"DepthStencilView",
"DeviceMemoryBarrier",
"DeviceMemroyBarrierWithGroupSync",
"DomainShader",
"EvaluateAttributeAtCentroid",
"EvaluateAttributeAtSample",
"EvaluateAttributeSnapped",
"FOG",
"Filter",
"GeometryShader",
"GetRenderTargetSampleCount",
"GetRenderTargetSamplePosition",
"GroupMemoryBarrier",
"GroupMemroyBarrierWithGroupSync",
"Hullshader",
"InputPatch",
"InterlockedAdd",
"InterlockedAnd",
"InterlockedCompareExchange",
"InterlockedCompareStore",
"InterlockedExchange",
"InterlockedMax",
"InterlockedMin",
"InterlockedOr",
"InterlockedXor",
"LineStream",
"MaxAnisotropy",
"MaxLOD",
"MinLOD",
"MipLODBias",
"NORMAL",
"NULL",
"Normal",
"OutputPatch",
"POSITION",
"POSITIONT",
"PSIZE",
"PixelShader",
"PointStream",
"Process2DQuadTessFactorsAvg",
"Process2DQuadTessFactorsMax",
"Process2DQuadTessFactorsMin",
"ProcessIsolineTessFactors",
"ProcessQuadTessFactorsAvg",
"ProcessQuadTessFactorsMax",
"ProcessQuadTessFactorsMin",
"ProcessTriTessFactorsAvg",
"ProcessTriTessFactorsMax",
"ProcessTriTessFactorsMin",
"RWBuffer",
"RWByteAddressBuffer",
"RWStructuredBuffer",
"RWTexture1D",
"RWTexture2D",
"RWTexture2DArray",
"RWTexture3D",
"RasterizerState",
"RenderTargetView",
"SV_ClipDistance",
"SV_Coverage",
"SV_CullDistance",
"SV_Depth",
"SV_DepthGreaterEqual",
"SV_DepthLessEqual",
"SV_DispatchThreadID",
"SV_DomainLocation",
"SV_GSInstanceID",
"SV_GroupID",
"SV_GroupIndex",
"SV_GroupThreadID",
"SV_InnerCoverage",
"SV_InsideTessFactor",
"SV_InstanceID",
"SV_IsFrontFace",
"SV_OutputControlPointID",
"SV_Position",
"SV_PrimitiveID",
"SV_RenderTargetArrayIndex",
"SV_SampleIndex",
"SV_StencilRef",
"SV_Target",
"SV_TessFactor",
"SV_VertexArrayIndex",
"SV_VertexID",
"Sampler",
"Sampler1D",
"Sampler2D",
"Sampler3D",
"SamplerCUBE",
"StructuredBuffer",
"TANGENT",
"TESSFACTOR",
"TEXCOORD",
"Texcoord",
"Texture",
"Texture1D",
"Texture2D",
"Texture2DArray",
"Texture2DMS",
"Texture2DMSArray",
"Texture3D",
"TextureCube",
"TextureCubeArray",
"TriangleStream",
"VFACE",
"VPOS",
"VertexShader",
"abort",
// "abs", // WGSL intrinsic
// "acos", // WGSL intrinsic
// "all", // WGSL intrinsic
"allow_uav_condition",
// "any", // WGSL intrinsic
"asdouble",
"asfloat",
// "asin", // WGSL intrinsic
"asint",
// "asm", // WGSL keyword
"asm_fragment",
"asuint",
// "atan", // WGSL intrinsic
// "atan2", // WGSL intrinsic
"auto",
// "bool", // WGSL keyword
"bool1",
"bool1x1",
"bool1x2",
"bool1x3",
"bool1x4",
"bool2",
"bool2x1",
"bool2x2",
"bool2x3",
"bool2x4",
"bool3",
"bool3x1",
"bool3x2",
"bool3x3",
"bool3x4",
"bool4",
"bool4x1",
"bool4x2",
"bool4x3",
"bool4x4",
"branch",
// "break", // WGSL keyword
// "call", // WGSL intrinsic
// "case", // WGSL keyword
"catch",
"cbuffer",
// "ceil", // WGSL intrinsic
"centroid",
"char",
// "clamp", // WGSL intrinsic
"class",
"clip",
"column_major",
"compile_fragment",
// "const", // WGSL keyword
"const_cast",
// "continue", // WGSL keyword
// "cos", // WGSL intrinsic
// "cosh", // WGSL intrinsic
"countbits",
// "cross", // WGSL intrinsic
"ddx",
"ddx_coarse",
"ddx_fine",
"ddy",
"ddy_coarse",
"ddy_fine",
"degrees",
"delete",
// "determinant", // WGSL intrinsic
// "discard", // WGSL keyword
// "distance", // WGSL intrinsic
// "do", // WGSL keyword
// "dot", // WGSL intrinsic
"double",
"double1",
"double1x1",
"double1x2",
"double1x3",
"double1x4",
"double2",
"double2x1",
"double2x2",
"double2x3",
"double2x4",
"double3",
"double3x1",
"double3x2",
"double3x3",
"double3x4",
"double4",
"double4x1",
"double4x2",
"double4x3",
"double4x4",
"dst",
"dword",
"dword1",
"dword1x1",
"dword1x2",
"dword1x3",
"dword1x4",
"dword2",
"dword2x1",
"dword2x2",
"dword2x3",
"dword2x4",
"dword3",
"dword3x1",
"dword3x2",
"dword3x3",
"dword3x4",
"dword4",
"dword4x1",
"dword4x2",
"dword4x3",
"dword4x4",
"dynamic_cast",
// "else", // WGSL keyword
// "enum", // WGSL keyword
"errorf",
// "exp", // WGSL intrinsic
// "exp2", // WGSL intrinsic
"explicit",
"export",
"extern",
"f16to32",
"f32tof16",
// "faceforward", // WGSL intrinsic
// "false", // WGSL keyword
"fastopt",
"firstbithigh",
"firstbitlow",
"flatten",
"float",
"float1",
"float1x1",
"float1x2",
"float1x3",
"float1x4",
"float2",
"float2x1",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x1",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x1",
"float4x2",
"float4x3",
"float4x4",
// "floor", // WGSL intrinsic
// "fma", // WGSL intrinsic
"fmod",
// "for", // WGSL keyword
"forcecase",
"frac",
// "frexp", // WGSL intrinsic
"friend",
// "fwidth", // WGSL intrinsic
"fxgroup",
"goto",
"groupshared",
"half",
"half1",
"half1x1",
"half1x2",
"half1x3",
"half1x4",
"half2",
"half2x1",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x1",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x1",
"half4x2",
"half4x3",
"half4x4",
// "if", // WGSL keyword
// "in", // WGSL keyword
"inline",
"inout",
"int",
"int1",
"int1x1",
"int1x2",
"int1x3",
"int1x4",
"int2",
"int2x1",
"int2x2",
"int2x3",
"int2x4",
"int3",
"int3x1",
"int3x2",
"int3x3",
"int3x4",
"int4",
"int4x1",
"int4x2",
"int4x3",
"int4x4",
"interface",
"isfinite",
"isinf",
"isnan",
// "ldexp", // WGSL intrinsic
// "length", // WGSL intrinsic
"lerp",
"lineadj",
"linear",
"lit",
// "log", // WGSL intrinsic
"log10",
// "log2", // WGSL intrinsic
"long",
// "loop", // WGSL keyword
"mad",
"matrix",
// "max", // WGSL intrinsic
// "min", // WGSL intrinsic
"min10float",
"min10float1",
"min10float1x1",
"min10float1x2",
"min10float1x3",
"min10float1x4",
"min10float2",
"min10float2x1",
"min10float2x2",
"min10float2x3",
"min10float2x4",
"min10float3",
"min10float3x1",
"min10float3x2",
"min10float3x3",
"min10float3x4",
"min10float4",
"min10float4x1",
"min10float4x2",
"min10float4x3",
"min10float4x4",
"min12int",
"min12int1",
"min12int1x1",
"min12int1x2",
"min12int1x3",
"min12int1x4",
"min12int2",
"min12int2x1",
"min12int2x2",
"min12int2x3",
"min12int2x4",
"min12int3",
"min12int3x1",
"min12int3x2",
"min12int3x3",
"min12int3x4",
"min12int4",
"min12int4x1",
"min12int4x2",
"min12int4x3",
"min12int4x4",
"min16float",
"min16float1",
"min16float1x1",
"min16float1x2",
"min16float1x3",
"min16float1x4",
"min16float2",
"min16float2x1",
"min16float2x2",
"min16float2x3",
"min16float2x4",
"min16float3",
"min16float3x1",
"min16float3x2",
"min16float3x3",
"min16float3x4",
"min16float4",
"min16float4x1",
"min16float4x2",
"min16float4x3",
"min16float4x4",
"min16int",
"min16int1",
"min16int1x1",
"min16int1x2",
"min16int1x3",
"min16int1x4",
"min16int2",
"min16int2x1",
"min16int2x2",
"min16int2x3",
"min16int2x4",
"min16int3",
"min16int3x1",
"min16int3x2",
"min16int3x3",
"min16int3x4",
"min16int4",
"min16int4x1",
"min16int4x2",
"min16int4x3",
"min16int4x4",
"min16uint",
"min16uint1",
"min16uint1x1",
"min16uint1x2",
"min16uint1x3",
"min16uint1x4",
"min16uint2",
"min16uint2x1",
"min16uint2x2",
"min16uint2x3",
"min16uint2x4",
"min16uint3",
"min16uint3x1",
"min16uint3x2",
"min16uint3x3",
"min16uint3x4",
"min16uint4",
"min16uint4x1",
"min16uint4x2",
"min16uint4x3",
"min16uint4x4",
// "modf", // WGSL intrinsic
"msad4",
"mul",
"mutable",
"namespace",
"new",
"nointerpolation",
"noise",
"noperspective",
// "normalize", // WGSL intrinsic
"numthreads",
"operator",
// "out", // WGSL keyword
"packoffset",
"pass",
"pixelfragment",
"pixelshader",
"point",
// "pow", // WGSL intrinsic
"precise",
"printf",
// "private", // WGSL keyword
"protected",
"public",
"radians",
"rcp",
// "reflect", // WGSL intrinsic
"refract",
"register",
"reinterpret_cast",
// "return", // WGSL keyword
// "reversebits", // WGSL intrinsic
// "round", // WGSL intrinsic
"row_major",
"rsqrt",
"sample",
"sampler1D",
"sampler2D",
"sampler3D",
"samplerCUBE",
"sampler_state",
"saturate",
"shared",
"short",
// "sign", // WGSL intrinsic
"signed",
// "sin", // WGSL intrinsic
"sincos",
// "sinh", // WGSL intrinsic
"sizeof",
// "smoothstep", // WGSL intrinsic
"snorm",
// "sqrt", // WGSL intrinsic
"stateblock",
"stateblock_state",
"static",
"static_cast",
// "step", // WGSL intrinsic
"string",
// "struct", // WGSL keyword
// "switch", // WGSL keyword
// "tan", // WGSL intrinsic
// "tanh", // WGSL intrinsic
"tbuffer",
"technique",
"technique10",
"technique11",
"template",
"tex1D",
"tex1Dbias",
"tex1Dgrad",
"tex1Dlod",
"tex1Dproj",
"tex2D",
"tex2Dbias",
"tex2Dgrad",
"tex2Dlod",
"tex2Dproj",
"tex3D",
"tex3Dbias",
"tex3Dgrad",
"tex3Dlod",
"tex3Dproj",
"texCUBE",
"texCUBEbias",
"texCUBEgrad",
"texCUBElod",
"texCUBEproj",
"texture",
"texture1D",
"texture1DArray",
"texture2D",
"texture2DArray",
"texture2DMS",
"texture2DMSArray",
"texture3D",
"textureCube",
"textureCubeArray",
"this",
"throw",
"transpose",
"triangle",
"triangleadj",
// "true", // WGSL keyword
// "trunc", // WGSL intrinsic
"try",
// "typedef", // WGSL keyword
"typename",
"uint",
"uint1",
"uint1x1",
"uint1x2",
"uint1x3",
"uint1x4",
"uint2",
"uint2x1",
"uint2x2",
"uint2x3",
"uint2x4",
"uint3",
"uint3x1",
"uint3x2",
"uint3x3",
"uint3x4",
"uint4",
"uint4x1",
"uint4x2",
"uint4x3",
"uint4x4",
// "uniform", // WGSL keyword
"union",
"unorm",
"unroll",
"unsigned",
"using",
"vector",
"vertexfragment",
"vertexshader",
"virtual",
// "void", // WGSL keyword
"volatile",
"while"));
} // namespace } // namespace
} // namespace transform } // namespace transform
} // namespace tint } // namespace tint

View File

@ -16,251 +16,11 @@
#include <utility> #include <utility>
#include "src/program_builder.h"
#include "src/transform/canonicalize_entry_point_io.h" #include "src/transform/canonicalize_entry_point_io.h"
#include "src/transform/manager.h" #include "src/transform/manager.h"
namespace tint { namespace tint {
namespace transform { namespace transform {
namespace {
// This list is used for a binary search and must be kept in sorted order.
const char* kReservedKeywords[] = {"access",
"alignas",
"alignof",
"and",
"and_eq",
"array",
"array_ref",
"as_type",
"asm",
"atomic",
"atomic_bool",
"atomic_int",
"atomic_uint",
"auto",
"bitand",
"bitor",
"bool",
"bool2",
"bool3",
"bool4",
"break",
"buffer",
"case",
"catch",
"char",
"char16_t",
"char2",
"char3",
"char32_t",
"char4",
"class",
"compl",
"const",
"const_cast",
"const_reference",
"constant",
"constexpr",
"continue",
"decltype",
"default",
"delete",
"depth2d",
"depth2d_array",
"depth2d_ms",
"depth2d_ms_array",
"depthcube",
"depthcube_array",
"device",
"discard_fragment",
"do",
"double",
"dynamic_cast",
"else",
"enum",
"explicit",
"extern",
"false",
"final",
"float",
"float2",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x2",
"float4x3",
"float4x4",
"for",
"fragment",
"friend",
"goto",
"half",
"half2",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x2",
"half4x3",
"half4x4",
"if",
"imageblock",
"inline",
"int",
"int16_t",
"int2",
"int3",
"int32_t",
"int4",
"int64_t",
"int8_t",
"kernel",
"long",
"long2",
"long3",
"long4",
"main",
"metal",
"mutable",
"namespace",
"new",
"noexcept",
"not",
"not_eq",
"nullptr",
"operator",
"or",
"or_eq",
"override",
"packed_bool2",
"packed_bool3",
"packed_bool4",
"packed_char2",
"packed_char3",
"packed_char4",
"packed_float2",
"packed_float3",
"packed_float4",
"packed_half2",
"packed_half3",
"packed_half4",
"packed_int2",
"packed_int3",
"packed_int4",
"packed_short2",
"packed_short3",
"packed_short4",
"packed_uchar2",
"packed_uchar3",
"packed_uchar4",
"packed_uint2",
"packed_uint3",
"packed_uint4",
"packed_ushort2",
"packed_ushort3",
"packed_ushort4",
"patch_control_point",
"private",
"protected",
"ptrdiff_t",
"public",
"r16snorm",
"r16unorm",
"r8unorm",
"reference",
"register",
"reinterpret_cast",
"return",
"rg11b10f",
"rg16snorm",
"rg16unorm",
"rg8snorm",
"rg8unorm",
"rgb10a2",
"rgb9e5",
"rgba16snorm",
"rgba16unorm",
"rgba8snorm",
"rgba8unorm",
"sampler",
"short",
"short2",
"short3",
"short4",
"signed",
"size_t",
"sizeof",
"srgba8unorm",
"static",
"static_assert",
"static_cast",
"struct",
"switch",
"template",
"texture",
"texture1d",
"texture1d_array",
"texture2d",
"texture2d_array",
"texture2d_ms",
"texture2d_ms_array",
"texture3d",
"texture_buffer",
"texturecube",
"texturecube_array",
"this",
"thread",
"thread_local",
"threadgroup",
"threadgroup_imageblock",
"throw",
"true",
"try",
"typedef",
"typeid",
"typename",
"uchar",
"uchar2",
"uchar3",
"uchar4",
"uint",
"uint16_t",
"uint2",
"uint3",
"uint32_t",
"uint4",
"uint64_t",
"uint8_t",
"ulong2",
"ulong3",
"ulong4",
"uniform",
"union",
"unsigned",
"ushort",
"ushort2",
"ushort3",
"ushort4",
"using",
"vec",
"vertex",
"virtual",
"void",
"volatile",
"wchar_t",
"while",
"xor",
"xor_eq"};
} // namespace
Msl::Msl() = default; Msl::Msl() = default;
Msl::~Msl() = default; Msl::~Msl() = default;
@ -272,12 +32,7 @@ Transform::Output Msl::Run(const Program* in, const DataMap& data) {
if (!out.program.IsValid()) { if (!out.program.IsValid()) {
return out; return out;
} }
return Output{Program(std::move(out.program))};
ProgramBuilder builder;
CloneContext ctx(&builder, &out.program);
RenameReservedKeywords(&ctx, kReservedKeywords);
ctx.Clone();
return Output{Program(std::move(builder))};
} }
} // namespace transform } // namespace transform

View File

@ -14,363 +14,12 @@
#include "src/transform/msl.h" #include "src/transform/msl.h"
#include <string>
#include "src/transform/test_helper.h" #include "src/transform/test_helper.h"
namespace tint { namespace tint {
namespace transform { namespace transform {
namespace { namespace {
using MslReservedKeywordTest = TransformTestWithParam<std::string>;
TEST_F(MslReservedKeywordTest, Basic) {
auto* src = R"(
struct class {
delete : i32;
};
[[stage(fragment)]]
fn main() {
var foo : i32;
var half : f32;
var half1 : f32;
var half2 : f32;
var tint_half2 : f32;
}
)";
auto* expect = R"(
struct tint_class {
tint_delete : i32;
};
[[stage(fragment)]]
fn tint_main() {
var foo : i32;
var tint_half : f32;
var half1 : f32;
var tint_half2 : f32;
var tint_half2_1 : f32;
}
)";
auto got = Run<Msl>(src);
EXPECT_EQ(expect, str(got));
}
TEST_P(MslReservedKeywordTest, Keywords) {
auto keyword = GetParam();
auto src = R"(
[[stage(fragment)]]
fn main() {
var )" + keyword +
R"( : i32;
}
)";
auto expect = R"(
[[stage(fragment)]]
fn tint_main() {
var tint_)" + keyword +
R"( : i32;
}
)";
auto got = Run<Msl>(src);
EXPECT_EQ(expect, str(got));
}
TEST_P(MslReservedKeywordTest, AttemptSymbolCollision) {
auto keyword = GetParam();
auto src = R"(
[[stage(fragment)]]
fn frag_main() {
var tint_)" +
keyword +
R"( : i32;
var tint_)" +
keyword +
R"(_1 : i32;
var )" + keyword +
R"( : i32;
var tint_)" +
keyword +
R"(_2 : i32;
var tint_)" +
keyword +
R"(_3 : i32;
}
)";
auto expect = R"(
[[stage(fragment)]]
fn frag_main() {
var tint_)" + keyword +
R"( : i32;
var tint_)" + keyword +
R"(_1 : i32;
var tint_)" + keyword +
R"(_2 : i32;
var tint_)" + keyword +
R"(_2_1 : i32;
var tint_)" + keyword +
R"(_3 : i32;
}
)";
auto got = Run<Msl>(src);
EXPECT_EQ(expect, str(got));
}
INSTANTIATE_TEST_SUITE_P(MslReservedKeywordTest,
MslReservedKeywordTest,
testing::Values(
// c++14 spec
"alignas",
"alignof",
"and",
"and_eq",
// "asm", // Also reserved in WGSL
"auto",
"bitand",
"bitor",
// "bool", // Also used in WGSL
// "break", // Also used in WGSL
// "case", // Also used in WGSL
"catch",
"char",
"char16_t",
"char32_t",
"class",
"compl",
// "const", // Also used in WGSL
"const_cast",
"constexpr",
// "continue", // Also used in WGSL
"decltype",
// "default", // Also used in WGSL
"delete",
// "do", // Also used in WGSL
"double",
"dynamic_cast",
// "else", // Also used in WGSL
// "enum", // Also used in WGSL
"explicit",
"extern",
// "false", // Also used in WGSL
"final",
"float",
// "for", // Also used in WGSL
"friend",
"goto",
// "if", // Also used in WGSL
"inline",
"int",
"long",
"mutable",
"namespace",
"new",
"noexcept",
"not",
"not_eq",
"nullptr",
"operator",
"or",
"or_eq",
"override",
// "private", // Also used in WGSL
"protected",
"public",
"register",
"reinterpret_cast",
// "return", // Also used in WGSL
"short",
"signed",
"sizeof",
"static",
"static_assert",
"static_cast",
// "struct", // Also used in WGSL
// "switch", // Also used in WGSL
"template",
"this",
"thread_local",
"throw",
// "true", // Also used in WGSL
"try",
// "typedef", // Also used in WGSL
"typeid",
"typename",
"union",
"unsigned",
"using",
"virtual",
// "void", // Also used in WGSL
"volatile",
"wchar_t",
"while",
"xor",
"xor_eq",
// Metal Spec
"access",
// "array", // Also used in WGSL
"array_ref",
"as_type",
"atomic",
"atomic_bool",
"atomic_int",
"atomic_uint",
"bool2",
"bool3",
"bool4",
"buffer",
"char2",
"char3",
"char4",
"const_reference",
"constant",
"depth2d",
"depth2d_array",
"depth2d_ms",
"depth2d_ms_array",
"depthcube",
"depthcube_array",
"device",
"discard_fragment",
"float2",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x2",
"float4x3",
"float4x4",
"fragment",
"half",
"half2",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x2",
"half4x3",
"half4x4",
"imageblock",
"int16_t",
"int2",
"int3",
"int32_t",
"int4",
"int64_t",
"int8_t",
"kernel",
"long2",
"long3",
"long4",
"main", // No functions called main
"metal", // The namespace
"packed_bool2",
"packed_bool3",
"packed_bool4",
"packed_char2",
"packed_char3",
"packed_char4",
"packed_float2",
"packed_float3",
"packed_float4",
"packed_half2",
"packed_half3",
"packed_half4",
"packed_int2",
"packed_int3",
"packed_int4",
"packed_short2",
"packed_short3",
"packed_short4",
"packed_uchar2",
"packed_uchar3",
"packed_uchar4",
"packed_uint2",
"packed_uint3",
"packed_uint4",
"packed_ushort2",
"packed_ushort3",
"packed_ushort4",
"patch_control_point",
"ptrdiff_t",
"r16snorm",
"r16unorm",
// "r8unorm", // Also used in WGSL
"reference",
"rg11b10f",
"rg16snorm",
"rg16unorm",
// "rg8snorm", // Also used in WGSL
// "rg8unorm", // Also used in WGSL
"rgb10a2",
"rgb9e5",
"rgba16snorm",
"rgba16unorm",
// "rgba8snorm", // Also used in WGSL
// "rgba8unorm", // Also used in WGSL
// "sampler", // Also used in WGSL
"short2",
"short3",
"short4",
"size_t",
"srgba8unorm",
"texture",
"texture1d",
"texture1d_array",
"texture2d",
"texture2d_array",
"texture2d_ms",
"texture2d_ms_array",
"texture3d",
"texture_buffer",
"texturecube",
"texturecube_array",
"thread",
"threadgroup",
"threadgroup_imageblock",
"uchar",
"uchar2",
"uchar3",
"uchar4",
"uint",
"uint16_t",
"uint2",
"uint3",
"uint32_t",
"uint4",
"uint64_t",
"uint8_t",
"ulong2",
"ulong3",
"ulong4",
// "uniform", // Also used in WGSL
"ushort",
"ushort2",
"ushort3",
"ushort4",
"vec",
"vertex"));
} // namespace } // namespace
} // namespace transform } // namespace transform
} // namespace tint } // namespace tint

View File

@ -27,6 +27,813 @@ TINT_INSTANTIATE_TYPEINFO(tint::transform::Renamer::Data);
namespace tint { namespace tint {
namespace transform { namespace transform {
namespace {
// This list is used for a binary search and must be kept in sorted order.
const char* kReservedKeywordsHLSL[] = {"AddressU",
"AddressV",
"AddressW",
"AllMemoryBarrier",
"AllMemoryBarrierWithGroupSync",
"AppendStructuredBuffer",
"BINORMAL",
"BLENDINDICES",
"BLENDWEIGHT",
"BlendState",
"BorderColor",
"Buffer",
"ByteAddressBuffer",
"COLOR",
"CheckAccessFullyMapped",
"ComparisonFunc",
"CompileShader",
"ComputeShader",
"ConsumeStructuredBuffer",
"D3DCOLORtoUBYTE4",
"DEPTH",
"DepthStencilState",
"DepthStencilView",
"DeviceMemoryBarrier",
"DeviceMemroyBarrierWithGroupSync",
"DomainShader",
"EvaluateAttributeAtCentroid",
"EvaluateAttributeAtSample",
"EvaluateAttributeSnapped",
"FOG",
"Filter",
"GeometryShader",
"GetRenderTargetSampleCount",
"GetRenderTargetSamplePosition",
"GroupMemoryBarrier",
"GroupMemroyBarrierWithGroupSync",
"Hullshader",
"InputPatch",
"InterlockedAdd",
"InterlockedAnd",
"InterlockedCompareExchange",
"InterlockedCompareStore",
"InterlockedExchange",
"InterlockedMax",
"InterlockedMin",
"InterlockedOr",
"InterlockedXor",
"LineStream",
"MaxAnisotropy",
"MaxLOD",
"MinLOD",
"MipLODBias",
"NORMAL",
"NULL",
"Normal",
"OutputPatch",
"POSITION",
"POSITIONT",
"PSIZE",
"PixelShader",
"PointStream",
"Process2DQuadTessFactorsAvg",
"Process2DQuadTessFactorsMax",
"Process2DQuadTessFactorsMin",
"ProcessIsolineTessFactors",
"ProcessQuadTessFactorsAvg",
"ProcessQuadTessFactorsMax",
"ProcessQuadTessFactorsMin",
"ProcessTriTessFactorsAvg",
"ProcessTriTessFactorsMax",
"ProcessTriTessFactorsMin",
"RWBuffer",
"RWByteAddressBuffer",
"RWStructuredBuffer",
"RWTexture1D",
"RWTexture2D",
"RWTexture2DArray",
"RWTexture3D",
"RasterizerState",
"RenderTargetView",
"SV_ClipDistance",
"SV_Coverage",
"SV_CullDistance",
"SV_Depth",
"SV_DepthGreaterEqual",
"SV_DepthLessEqual",
"SV_DispatchThreadID",
"SV_DomainLocation",
"SV_GSInstanceID",
"SV_GroupID",
"SV_GroupIndex",
"SV_GroupThreadID",
"SV_InnerCoverage",
"SV_InsideTessFactor",
"SV_InstanceID",
"SV_IsFrontFace",
"SV_OutputControlPointID",
"SV_Position",
"SV_PrimitiveID",
"SV_RenderTargetArrayIndex",
"SV_SampleIndex",
"SV_StencilRef",
"SV_Target",
"SV_TessFactor",
"SV_VertexArrayIndex",
"SV_VertexID",
"Sampler",
"Sampler1D",
"Sampler2D",
"Sampler3D",
"SamplerCUBE",
"StructuredBuffer",
"TANGENT",
"TESSFACTOR",
"TEXCOORD",
"Texcoord",
"Texture",
"Texture1D",
"Texture2D",
"Texture2DArray",
"Texture2DMS",
"Texture2DMSArray",
"Texture3D",
"TextureCube",
"TextureCubeArray",
"TriangleStream",
"VFACE",
"VPOS",
"VertexShader",
"abort",
"allow_uav_condition",
"asdouble",
"asfloat",
"asint",
"asm",
"asm_fragment",
"asuint",
"auto",
"bool",
"bool1",
"bool1x1",
"bool1x2",
"bool1x3",
"bool1x4",
"bool2",
"bool2x1",
"bool2x2",
"bool2x3",
"bool2x4",
"bool3",
"bool3x1",
"bool3x2",
"bool3x3",
"bool3x4",
"bool4",
"bool4x1",
"bool4x2",
"bool4x3",
"bool4x4",
"branch",
"break",
"call",
"case",
"catch",
"cbuffer",
"centroid",
"char",
"class",
"clip",
"column_major",
"compile_fragment",
"const",
"const_cast",
"continue",
"countbits",
"ddx",
"ddx_coarse",
"ddx_fine",
"ddy",
"ddy_coarse",
"ddy_fine",
"degrees",
"delete",
"discard",
"do",
"double",
"double1",
"double1x1",
"double1x2",
"double1x3",
"double1x4",
"double2",
"double2x1",
"double2x2",
"double2x3",
"double2x4",
"double3",
"double3x1",
"double3x2",
"double3x3",
"double3x4",
"double4",
"double4x1",
"double4x2",
"double4x3",
"double4x4",
"dst",
"dword",
"dword1",
"dword1x1",
"dword1x2",
"dword1x3",
"dword1x4",
"dword2",
"dword2x1",
"dword2x2",
"dword2x3",
"dword2x4",
"dword3",
"dword3x1",
"dword3x2",
"dword3x3",
"dword3x4",
"dword4",
"dword4x1",
"dword4x2",
"dword4x3",
"dword4x4",
"dynamic_cast",
"else",
"enum",
"errorf",
"explicit",
"export",
"extern",
"f16to32",
"f32tof16",
"false",
"fastopt",
"firstbithigh",
"firstbitlow",
"flatten",
"float",
"float1",
"float1x1",
"float1x2",
"float1x3",
"float1x4",
"float2",
"float2x1",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x1",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x1",
"float4x2",
"float4x3",
"float4x4",
"fmod",
"for",
"forcecase",
"frac",
"friend",
"fxgroup",
"goto",
"groupshared",
"half",
"half1",
"half1x1",
"half1x2",
"half1x3",
"half1x4",
"half2",
"half2x1",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x1",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x1",
"half4x2",
"half4x3",
"half4x4",
"if",
"in",
"inline",
"inout",
"int",
"int1",
"int1x1",
"int1x2",
"int1x3",
"int1x4",
"int2",
"int2x1",
"int2x2",
"int2x3",
"int2x4",
"int3",
"int3x1",
"int3x2",
"int3x3",
"int3x4",
"int4",
"int4x1",
"int4x2",
"int4x3",
"int4x4",
"interface",
"isfinite",
"isinf",
"isnan",
"lerp",
"lineadj",
"linear",
"lit",
"log10",
"long",
"loop",
"mad",
"matrix",
"min10float",
"min10float1",
"min10float1x1",
"min10float1x2",
"min10float1x3",
"min10float1x4",
"min10float2",
"min10float2x1",
"min10float2x2",
"min10float2x3",
"min10float2x4",
"min10float3",
"min10float3x1",
"min10float3x2",
"min10float3x3",
"min10float3x4",
"min10float4",
"min10float4x1",
"min10float4x2",
"min10float4x3",
"min10float4x4",
"min12int",
"min12int1",
"min12int1x1",
"min12int1x2",
"min12int1x3",
"min12int1x4",
"min12int2",
"min12int2x1",
"min12int2x2",
"min12int2x3",
"min12int2x4",
"min12int3",
"min12int3x1",
"min12int3x2",
"min12int3x3",
"min12int3x4",
"min12int4",
"min12int4x1",
"min12int4x2",
"min12int4x3",
"min12int4x4",
"min16float",
"min16float1",
"min16float1x1",
"min16float1x2",
"min16float1x3",
"min16float1x4",
"min16float2",
"min16float2x1",
"min16float2x2",
"min16float2x3",
"min16float2x4",
"min16float3",
"min16float3x1",
"min16float3x2",
"min16float3x3",
"min16float3x4",
"min16float4",
"min16float4x1",
"min16float4x2",
"min16float4x3",
"min16float4x4",
"min16int",
"min16int1",
"min16int1x1",
"min16int1x2",
"min16int1x3",
"min16int1x4",
"min16int2",
"min16int2x1",
"min16int2x2",
"min16int2x3",
"min16int2x4",
"min16int3",
"min16int3x1",
"min16int3x2",
"min16int3x3",
"min16int3x4",
"min16int4",
"min16int4x1",
"min16int4x2",
"min16int4x3",
"min16int4x4",
"min16uint",
"min16uint1",
"min16uint1x1",
"min16uint1x2",
"min16uint1x3",
"min16uint1x4",
"min16uint2",
"min16uint2x1",
"min16uint2x2",
"min16uint2x3",
"min16uint2x4",
"min16uint3",
"min16uint3x1",
"min16uint3x2",
"min16uint3x3",
"min16uint3x4",
"min16uint4",
"min16uint4x1",
"min16uint4x2",
"min16uint4x3",
"min16uint4x4",
"msad4",
"mul",
"mutable",
"namespace",
"new",
"nointerpolation",
"noise",
"noperspective",
"numthreads",
"operator",
"out",
"packoffset",
"pass",
"pixelfragment",
"pixelshader",
"point",
"precise",
"printf",
"private",
"protected",
"public",
"radians",
"rcp",
"refract",
"register",
"reinterpret_cast",
"return",
"row_major",
"rsqrt",
"sample",
"sampler",
"sampler1D",
"sampler2D",
"sampler3D",
"samplerCUBE",
"sampler_state",
"saturate",
"shared",
"short",
"signed",
"sincos",
"sizeof",
"snorm",
"stateblock",
"stateblock_state",
"static",
"static_cast",
"string",
"struct",
"switch",
"tbuffer",
"technique",
"technique10",
"technique11",
"template",
"tex1D",
"tex1Dbias",
"tex1Dgrad",
"tex1Dlod",
"tex1Dproj",
"tex2D",
"tex2Dbias",
"tex2Dgrad",
"tex2Dlod",
"tex2Dproj",
"tex3D",
"tex3Dbias",
"tex3Dgrad",
"tex3Dlod",
"tex3Dproj",
"texCUBE",
"texCUBEbias",
"texCUBEgrad",
"texCUBElod",
"texCUBEproj",
"texture",
"texture1D",
"texture1DArray",
"texture2D",
"texture2DArray",
"texture2DMS",
"texture2DMSArray",
"texture3D",
"textureCube",
"textureCubeArray",
"this",
"throw",
"transpose",
"triangle",
"triangleadj",
"true",
"try",
"typedef",
"typename",
"uint",
"uint1",
"uint1x1",
"uint1x2",
"uint1x3",
"uint1x4",
"uint2",
"uint2x1",
"uint2x2",
"uint2x3",
"uint2x4",
"uint3",
"uint3x1",
"uint3x2",
"uint3x3",
"uint3x4",
"uint4",
"uint4x1",
"uint4x2",
"uint4x3",
"uint4x4",
"uniform",
"union",
"unorm",
"unroll",
"unsigned",
"using",
"vector",
"vertexfragment",
"vertexshader",
"virtual",
"void",
"volatile",
"while"};
// This list is used for a binary search and must be kept in sorted order.
const char* kReservedKeywordsMSL[] = {"access",
"alignas",
"alignof",
"and",
"and_eq",
"array",
"array_ref",
"as_type",
"asm",
"atomic",
"atomic_bool",
"atomic_int",
"atomic_uint",
"auto",
"bitand",
"bitor",
"bool",
"bool2",
"bool3",
"bool4",
"break",
"buffer",
"case",
"catch",
"char",
"char16_t",
"char2",
"char3",
"char32_t",
"char4",
"class",
"compl",
"const",
"const_cast",
"const_reference",
"constant",
"constexpr",
"continue",
"decltype",
"default",
"delete",
"depth2d",
"depth2d_array",
"depth2d_ms",
"depth2d_ms_array",
"depthcube",
"depthcube_array",
"device",
"discard_fragment",
"do",
"double",
"dynamic_cast",
"else",
"enum",
"explicit",
"extern",
"false",
"final",
"float",
"float2",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x2",
"float4x3",
"float4x4",
"for",
"fragment",
"friend",
"goto",
"half",
"half2",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x2",
"half4x3",
"half4x4",
"if",
"imageblock",
"inline",
"int",
"int16_t",
"int2",
"int3",
"int32_t",
"int4",
"int64_t",
"int8_t",
"kernel",
"long",
"long2",
"long3",
"long4",
"main",
"metal",
"mutable",
"namespace",
"new",
"noexcept",
"not",
"not_eq",
"nullptr",
"operator",
"or",
"or_eq",
"override",
"packed_bool2",
"packed_bool3",
"packed_bool4",
"packed_char2",
"packed_char3",
"packed_char4",
"packed_float2",
"packed_float3",
"packed_float4",
"packed_half2",
"packed_half3",
"packed_half4",
"packed_int2",
"packed_int3",
"packed_int4",
"packed_short2",
"packed_short3",
"packed_short4",
"packed_uchar2",
"packed_uchar3",
"packed_uchar4",
"packed_uint2",
"packed_uint3",
"packed_uint4",
"packed_ushort2",
"packed_ushort3",
"packed_ushort4",
"patch_control_point",
"private",
"protected",
"ptrdiff_t",
"public",
"r16snorm",
"r16unorm",
"r8unorm",
"reference",
"register",
"reinterpret_cast",
"return",
"rg11b10f",
"rg16snorm",
"rg16unorm",
"rg8snorm",
"rg8unorm",
"rgb10a2",
"rgb9e5",
"rgba16snorm",
"rgba16unorm",
"rgba8snorm",
"rgba8unorm",
"sampler",
"short",
"short2",
"short3",
"short4",
"signed",
"size_t",
"sizeof",
"srgba8unorm",
"static",
"static_assert",
"static_cast",
"struct",
"switch",
"template",
"texture",
"texture1d",
"texture1d_array",
"texture2d",
"texture2d_array",
"texture2d_ms",
"texture2d_ms_array",
"texture3d",
"texture_buffer",
"texturecube",
"texturecube_array",
"this",
"thread",
"thread_local",
"threadgroup",
"threadgroup_imageblock",
"throw",
"true",
"try",
"typedef",
"typeid",
"typename",
"uchar",
"uchar2",
"uchar3",
"uchar4",
"uint",
"uint16_t",
"uint2",
"uint3",
"uint32_t",
"uint4",
"uint64_t",
"uint8_t",
"ulong2",
"ulong3",
"ulong4",
"uniform",
"union",
"unsigned",
"ushort",
"ushort2",
"ushort3",
"ushort4",
"using",
"vec",
"vertex",
"virtual",
"void",
"volatile",
"wchar_t",
"while",
"xor",
"xor_eq"};
} // namespace
Renamer::Data::Data(Remappings&& r) : remappings(std::move(r)) {} Renamer::Data::Data(Remappings&& r) : remappings(std::move(r)) {}
Renamer::Data::Data(const Data&) = default; Renamer::Data::Data(const Data&) = default;
@ -70,12 +877,36 @@ Transform::Output Renamer::Run(const Program* in, const DataMap&) {
Data::Remappings remappings; Data::Remappings remappings;
switch (cfg_.method) {
case Method::kMonotonic:
ctx.ReplaceAll([&](Symbol sym_in) { ctx.ReplaceAll([&](Symbol sym_in) {
auto name_in = ctx.src->Symbols().NameFor(sym_in);
switch (cfg_.target) {
case Target::kAll:
// Always rename.
break;
case Target::kHlslKeywords:
if (!std::binary_search(
kReservedKeywordsHLSL,
kReservedKeywordsHLSL +
sizeof(kReservedKeywordsHLSL) / sizeof(const char*),
name_in)) {
// No match, just reuse the original name.
return ctx.dst->Symbols().New(name_in);
}
break;
case Target::kMslKeywords:
if (!std::binary_search(
kReservedKeywordsMSL,
kReservedKeywordsMSL +
sizeof(kReservedKeywordsMSL) / sizeof(const char*),
name_in)) {
// No match, just reuse the original name.
return ctx.dst->Symbols().New(name_in);
}
break;
}
auto sym_out = ctx.dst->Symbols().New(); auto sym_out = ctx.dst->Symbols().New();
remappings.emplace(ctx.src->Symbols().NameFor(sym_in), remappings.emplace(name_in, ctx.dst->Symbols().NameFor(sym_out));
ctx.dst->Symbols().NameFor(sym_out));
return sym_out; return sym_out;
}); });
@ -90,8 +921,6 @@ Transform::Output Renamer::Run(const Program* in, const DataMap&) {
} }
return nullptr; // Clone ident. Uses the symbol remapping above. return nullptr; // Clone ident. Uses the symbol remapping above.
}); });
break;
}
ctx.Clone(); ctx.Clone();
return Output(Program(std::move(out)), return Output(Program(std::move(out)),

View File

@ -46,17 +46,20 @@ class Renamer : public Transform {
Remappings const remappings; Remappings const remappings;
}; };
/// Method is an enumerator of renaming methods that can be used /// Target is an enumerator of rename targets that can be used
enum class Method { enum class Target {
/// Every symbol will be replaced with an identifier containing a /// Rename every symbol.
/// monotonically incrementing integer. kAll,
kMonotonic, /// Only rename symbols that are reserved keywords in HLSL.
kHlslKeywords,
/// Only rename symbols that are reserved keywords in MSL.
kMslKeywords,
}; };
/// Configuration options for the transform /// Configuration options for the transform
struct Config { struct Config {
/// The method used for renaming symbols /// The targets to rename
Method method = Method::kMonotonic; Target target = Target::kAll;
}; };
/// Constructor using a default configuration /// Constructor using a default configuration

View File

@ -14,6 +14,8 @@
#include "src/transform/renamer.h" #include "src/transform/renamer.h"
#include <memory>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "src/transform/test_helper.h" #include "src/transform/test_helper.h"
@ -185,6 +187,908 @@ fn tint_symbol() -> [[builtin(position)]] vec4<f32> {
EXPECT_THAT(data->remappings, ContainerEq(expected_remappings)); EXPECT_THAT(data->remappings, ContainerEq(expected_remappings));
} }
using RenamerTestHlsl = TransformTestWithParam<std::string>;
using RenamerTestMsl = TransformTestWithParam<std::string>;
TEST_P(RenamerTestHlsl, Keywords) {
auto keyword = GetParam();
auto src = R"(
[[stage(fragment)]]
fn frag_main() {
var )" + keyword +
R"( : i32;
}
)";
auto* expect = R"(
[[stage(fragment)]]
fn frag_main() {
var tint_symbol : i32;
}
)";
Renamer::Config config{Renamer::Target::kHlslKeywords};
auto got = Run(src, std::make_unique<Renamer>(config));
EXPECT_EQ(expect, str(got));
}
TEST_P(RenamerTestMsl, Keywords) {
auto keyword = GetParam();
auto src = R"(
[[stage(fragment)]]
fn frag_main() {
var )" + keyword +
R"( : i32;
}
)";
auto* expect = R"(
[[stage(fragment)]]
fn frag_main() {
var tint_symbol : i32;
}
)";
Renamer::Config config{Renamer::Target::kMslKeywords};
auto got = Run(src, std::make_unique<Renamer>(config));
EXPECT_EQ(expect, str(got));
}
INSTANTIATE_TEST_SUITE_P(RenamerTestHlsl,
RenamerTestHlsl,
testing::Values("AddressU",
"AddressV",
"AddressW",
"AllMemoryBarrier",
"AllMemoryBarrierWithGroupSync",
"AppendStructuredBuffer",
"BINORMAL",
"BLENDINDICES",
"BLENDWEIGHT",
"BlendState",
"BorderColor",
"Buffer",
"ByteAddressBuffer",
"COLOR",
"CheckAccessFullyMapped",
"ComparisonFunc",
"CompileShader",
"ComputeShader",
"ConsumeStructuredBuffer",
"D3DCOLORtoUBYTE4",
"DEPTH",
"DepthStencilState",
"DepthStencilView",
"DeviceMemoryBarrier",
"DeviceMemroyBarrierWithGroupSync",
"DomainShader",
"EvaluateAttributeAtCentroid",
"EvaluateAttributeAtSample",
"EvaluateAttributeSnapped",
"FOG",
"Filter",
"GeometryShader",
"GetRenderTargetSampleCount",
"GetRenderTargetSamplePosition",
"GroupMemoryBarrier",
"GroupMemroyBarrierWithGroupSync",
"Hullshader",
"InputPatch",
"InterlockedAdd",
"InterlockedAnd",
"InterlockedCompareExchange",
"InterlockedCompareStore",
"InterlockedExchange",
"InterlockedMax",
"InterlockedMin",
"InterlockedOr",
"InterlockedXor",
"LineStream",
"MaxAnisotropy",
"MaxLOD",
"MinLOD",
"MipLODBias",
"NORMAL",
"NULL",
"Normal",
"OutputPatch",
"POSITION",
"POSITIONT",
"PSIZE",
"PixelShader",
"PointStream",
"Process2DQuadTessFactorsAvg",
"Process2DQuadTessFactorsMax",
"Process2DQuadTessFactorsMin",
"ProcessIsolineTessFactors",
"ProcessQuadTessFactorsAvg",
"ProcessQuadTessFactorsMax",
"ProcessQuadTessFactorsMin",
"ProcessTriTessFactorsAvg",
"ProcessTriTessFactorsMax",
"ProcessTriTessFactorsMin",
"RWBuffer",
"RWByteAddressBuffer",
"RWStructuredBuffer",
"RWTexture1D",
"RWTexture2D",
"RWTexture2DArray",
"RWTexture3D",
"RasterizerState",
"RenderTargetView",
"SV_ClipDistance",
"SV_Coverage",
"SV_CullDistance",
"SV_Depth",
"SV_DepthGreaterEqual",
"SV_DepthLessEqual",
"SV_DispatchThreadID",
"SV_DomainLocation",
"SV_GSInstanceID",
"SV_GroupID",
"SV_GroupIndex",
"SV_GroupThreadID",
"SV_InnerCoverage",
"SV_InsideTessFactor",
"SV_InstanceID",
"SV_IsFrontFace",
"SV_OutputControlPointID",
"SV_Position",
"SV_PrimitiveID",
"SV_RenderTargetArrayIndex",
"SV_SampleIndex",
"SV_StencilRef",
"SV_Target",
"SV_TessFactor",
"SV_VertexArrayIndex",
"SV_VertexID",
"Sampler",
"Sampler1D",
"Sampler2D",
"Sampler3D",
"SamplerCUBE",
"StructuredBuffer",
"TANGENT",
"TESSFACTOR",
"TEXCOORD",
"Texcoord",
"Texture",
"Texture1D",
"Texture2D",
"Texture2DArray",
"Texture2DMS",
"Texture2DMSArray",
"Texture3D",
"TextureCube",
"TextureCubeArray",
"TriangleStream",
"VFACE",
"VPOS",
"VertexShader",
"abort",
// "abs", // WGSL intrinsic
// "acos", // WGSL intrinsic
// "all", // WGSL intrinsic
"allow_uav_condition",
// "any", // WGSL intrinsic
"asdouble",
"asfloat",
// "asin", // WGSL intrinsic
"asint",
// "asm", // WGSL keyword
"asm_fragment",
"asuint",
// "atan", // WGSL intrinsic
// "atan2", // WGSL intrinsic
"auto",
// "bool", // WGSL keyword
"bool1",
"bool1x1",
"bool1x2",
"bool1x3",
"bool1x4",
"bool2",
"bool2x1",
"bool2x2",
"bool2x3",
"bool2x4",
"bool3",
"bool3x1",
"bool3x2",
"bool3x3",
"bool3x4",
"bool4",
"bool4x1",
"bool4x2",
"bool4x3",
"bool4x4",
"branch",
// "break", // WGSL keyword
// "call", // WGSL intrinsic
// "case", // WGSL keyword
"catch",
"cbuffer",
// "ceil", // WGSL intrinsic
"centroid",
"char",
// "clamp", // WGSL intrinsic
"class",
"clip",
"column_major",
"compile_fragment",
// "const", // WGSL keyword
"const_cast",
// "continue", // WGSL keyword
// "cos", // WGSL intrinsic
// "cosh", // WGSL intrinsic
"countbits",
// "cross", // WGSL intrinsic
"ddx",
"ddx_coarse",
"ddx_fine",
"ddy",
"ddy_coarse",
"ddy_fine",
"degrees",
"delete",
// "determinant", // WGSL intrinsic
// "discard", // WGSL keyword
// "distance", // WGSL intrinsic
// "do", // WGSL keyword
// "dot", // WGSL intrinsic
"double",
"double1",
"double1x1",
"double1x2",
"double1x3",
"double1x4",
"double2",
"double2x1",
"double2x2",
"double2x3",
"double2x4",
"double3",
"double3x1",
"double3x2",
"double3x3",
"double3x4",
"double4",
"double4x1",
"double4x2",
"double4x3",
"double4x4",
"dst",
"dword",
"dword1",
"dword1x1",
"dword1x2",
"dword1x3",
"dword1x4",
"dword2",
"dword2x1",
"dword2x2",
"dword2x3",
"dword2x4",
"dword3",
"dword3x1",
"dword3x2",
"dword3x3",
"dword3x4",
"dword4",
"dword4x1",
"dword4x2",
"dword4x3",
"dword4x4",
"dynamic_cast",
// "else", // WGSL keyword
// "enum", // WGSL keyword
"errorf",
// "exp", // WGSL intrinsic
// "exp2", // WGSL intrinsic
"explicit",
"export",
"extern",
"f16to32",
"f32tof16",
// "faceforward", // WGSL intrinsic
// "false", // WGSL keyword
"fastopt",
"firstbithigh",
"firstbitlow",
"flatten",
"float",
"float1",
"float1x1",
"float1x2",
"float1x3",
"float1x4",
"float2",
"float2x1",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x1",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x1",
"float4x2",
"float4x3",
"float4x4",
// "floor", // WGSL intrinsic
// "fma", // WGSL intrinsic
"fmod",
// "for", // WGSL keyword
"forcecase",
"frac",
// "frexp", // WGSL intrinsic
"friend",
// "fwidth", // WGSL intrinsic
"fxgroup",
"goto",
"groupshared",
"half",
"half1",
"half1x1",
"half1x2",
"half1x3",
"half1x4",
"half2",
"half2x1",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x1",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x1",
"half4x2",
"half4x3",
"half4x4",
// "if", // WGSL keyword
// "in", // WGSL keyword
"inline",
"inout",
"int",
"int1",
"int1x1",
"int1x2",
"int1x3",
"int1x4",
"int2",
"int2x1",
"int2x2",
"int2x3",
"int2x4",
"int3",
"int3x1",
"int3x2",
"int3x3",
"int3x4",
"int4",
"int4x1",
"int4x2",
"int4x3",
"int4x4",
"interface",
"isfinite",
"isinf",
"isnan",
// "ldexp", // WGSL intrinsic
// "length", // WGSL intrinsic
"lerp",
"lineadj",
"linear",
"lit",
// "log", // WGSL intrinsic
"log10",
// "log2", // WGSL intrinsic
"long",
// "loop", // WGSL keyword
"mad",
"matrix",
// "max", // WGSL intrinsic
// "min", // WGSL intrinsic
"min10float",
"min10float1",
"min10float1x1",
"min10float1x2",
"min10float1x3",
"min10float1x4",
"min10float2",
"min10float2x1",
"min10float2x2",
"min10float2x3",
"min10float2x4",
"min10float3",
"min10float3x1",
"min10float3x2",
"min10float3x3",
"min10float3x4",
"min10float4",
"min10float4x1",
"min10float4x2",
"min10float4x3",
"min10float4x4",
"min12int",
"min12int1",
"min12int1x1",
"min12int1x2",
"min12int1x3",
"min12int1x4",
"min12int2",
"min12int2x1",
"min12int2x2",
"min12int2x3",
"min12int2x4",
"min12int3",
"min12int3x1",
"min12int3x2",
"min12int3x3",
"min12int3x4",
"min12int4",
"min12int4x1",
"min12int4x2",
"min12int4x3",
"min12int4x4",
"min16float",
"min16float1",
"min16float1x1",
"min16float1x2",
"min16float1x3",
"min16float1x4",
"min16float2",
"min16float2x1",
"min16float2x2",
"min16float2x3",
"min16float2x4",
"min16float3",
"min16float3x1",
"min16float3x2",
"min16float3x3",
"min16float3x4",
"min16float4",
"min16float4x1",
"min16float4x2",
"min16float4x3",
"min16float4x4",
"min16int",
"min16int1",
"min16int1x1",
"min16int1x2",
"min16int1x3",
"min16int1x4",
"min16int2",
"min16int2x1",
"min16int2x2",
"min16int2x3",
"min16int2x4",
"min16int3",
"min16int3x1",
"min16int3x2",
"min16int3x3",
"min16int3x4",
"min16int4",
"min16int4x1",
"min16int4x2",
"min16int4x3",
"min16int4x4",
"min16uint",
"min16uint1",
"min16uint1x1",
"min16uint1x2",
"min16uint1x3",
"min16uint1x4",
"min16uint2",
"min16uint2x1",
"min16uint2x2",
"min16uint2x3",
"min16uint2x4",
"min16uint3",
"min16uint3x1",
"min16uint3x2",
"min16uint3x3",
"min16uint3x4",
"min16uint4",
"min16uint4x1",
"min16uint4x2",
"min16uint4x3",
"min16uint4x4",
// "modf", // WGSL intrinsic
"msad4",
"mul",
"mutable",
"namespace",
"new",
"nointerpolation",
"noise",
"noperspective",
// "normalize", // WGSL intrinsic
"numthreads",
"operator",
// "out", // WGSL keyword
"packoffset",
"pass",
"pixelfragment",
"pixelshader",
"point",
// "pow", // WGSL intrinsic
"precise",
"printf",
// "private", // WGSL keyword
"protected",
"public",
"radians",
"rcp",
// "reflect", // WGSL intrinsic
"refract",
"register",
"reinterpret_cast",
// "return", // WGSL keyword
// "reversebits", // WGSL intrinsic
// "round", // WGSL intrinsic
"row_major",
"rsqrt",
"sample",
"sampler1D",
"sampler2D",
"sampler3D",
"samplerCUBE",
"sampler_state",
"saturate",
"shared",
"short",
// "sign", // WGSL intrinsic
"signed",
// "sin", // WGSL intrinsic
"sincos",
// "sinh", // WGSL intrinsic
"sizeof",
// "smoothstep", // WGSL intrinsic
"snorm",
// "sqrt", // WGSL intrinsic
"stateblock",
"stateblock_state",
"static",
"static_cast",
// "step", // WGSL intrinsic
"string",
// "struct", // WGSL keyword
// "switch", // WGSL keyword
// "tan", // WGSL intrinsic
// "tanh", // WGSL intrinsic
"tbuffer",
"technique",
"technique10",
"technique11",
"template",
"tex1D",
"tex1Dbias",
"tex1Dgrad",
"tex1Dlod",
"tex1Dproj",
"tex2D",
"tex2Dbias",
"tex2Dgrad",
"tex2Dlod",
"tex2Dproj",
"tex3D",
"tex3Dbias",
"tex3Dgrad",
"tex3Dlod",
"tex3Dproj",
"texCUBE",
"texCUBEbias",
"texCUBEgrad",
"texCUBElod",
"texCUBEproj",
"texture",
"texture1D",
"texture1DArray",
"texture2D",
"texture2DArray",
"texture2DMS",
"texture2DMSArray",
"texture3D",
"textureCube",
"textureCubeArray",
"this",
"throw",
"transpose",
"triangle",
"triangleadj",
// "true", // WGSL keyword
// "trunc", // WGSL intrinsic
"try",
// "typedef", // WGSL keyword
"typename",
"uint",
"uint1",
"uint1x1",
"uint1x2",
"uint1x3",
"uint1x4",
"uint2",
"uint2x1",
"uint2x2",
"uint2x3",
"uint2x4",
"uint3",
"uint3x1",
"uint3x2",
"uint3x3",
"uint3x4",
"uint4",
"uint4x1",
"uint4x2",
"uint4x3",
"uint4x4",
// "uniform", // WGSL keyword
"union",
"unorm",
"unroll",
"unsigned",
"using",
"vector",
"vertexfragment",
"vertexshader",
"virtual",
// "void", // WGSL keyword
"volatile",
"while"));
INSTANTIATE_TEST_SUITE_P(RenamerTestMsl,
RenamerTestMsl,
testing::Values(
// c++14 spec
"alignas",
"alignof",
"and",
"and_eq",
// "asm", // Also reserved in WGSL
"auto",
"bitand",
"bitor",
// "bool", // Also used in WGSL
// "break", // Also used in WGSL
// "case", // Also used in WGSL
"catch",
"char",
"char16_t",
"char32_t",
"class",
"compl",
// "const", // Also used in WGSL
"const_cast",
"constexpr",
// "continue", // Also used in WGSL
"decltype",
// "default", // Also used in WGSL
"delete",
// "do", // Also used in WGSL
"double",
"dynamic_cast",
// "else", // Also used in WGSL
// "enum", // Also used in WGSL
"explicit",
"extern",
// "false", // Also used in WGSL
"final",
"float",
// "for", // Also used in WGSL
"friend",
"goto",
// "if", // Also used in WGSL
"inline",
"int",
"long",
"mutable",
"namespace",
"new",
"noexcept",
"not",
"not_eq",
"nullptr",
"operator",
"or",
"or_eq",
"override",
// "private", // Also used in WGSL
"protected",
"public",
"register",
"reinterpret_cast",
// "return", // Also used in WGSL
"short",
"signed",
"sizeof",
"static",
"static_assert",
"static_cast",
// "struct", // Also used in WGSL
// "switch", // Also used in WGSL
"template",
"this",
"thread_local",
"throw",
// "true", // Also used in WGSL
"try",
// "typedef", // Also used in WGSL
"typeid",
"typename",
"union",
"unsigned",
"using",
"virtual",
// "void", // Also used in WGSL
"volatile",
"wchar_t",
"while",
"xor",
"xor_eq",
// Metal Spec
"access",
// "array", // Also used in WGSL
"array_ref",
"as_type",
"atomic",
"atomic_bool",
"atomic_int",
"atomic_uint",
"bool2",
"bool3",
"bool4",
"buffer",
"char2",
"char3",
"char4",
"const_reference",
"constant",
"depth2d",
"depth2d_array",
"depth2d_ms",
"depth2d_ms_array",
"depthcube",
"depthcube_array",
"device",
"discard_fragment",
"float2",
"float2x2",
"float2x3",
"float2x4",
"float3",
"float3x2",
"float3x3",
"float3x4",
"float4",
"float4x2",
"float4x3",
"float4x4",
"fragment",
"half",
"half2",
"half2x2",
"half2x3",
"half2x4",
"half3",
"half3x2",
"half3x3",
"half3x4",
"half4",
"half4x2",
"half4x3",
"half4x4",
"imageblock",
"int16_t",
"int2",
"int3",
"int32_t",
"int4",
"int64_t",
"int8_t",
"kernel",
"long2",
"long3",
"long4",
"main", // No functions called main
"metal", // The namespace
"packed_bool2",
"packed_bool3",
"packed_bool4",
"packed_char2",
"packed_char3",
"packed_char4",
"packed_float2",
"packed_float3",
"packed_float4",
"packed_half2",
"packed_half3",
"packed_half4",
"packed_int2",
"packed_int3",
"packed_int4",
"packed_short2",
"packed_short3",
"packed_short4",
"packed_uchar2",
"packed_uchar3",
"packed_uchar4",
"packed_uint2",
"packed_uint3",
"packed_uint4",
"packed_ushort2",
"packed_ushort3",
"packed_ushort4",
"patch_control_point",
"ptrdiff_t",
"r16snorm",
"r16unorm",
// "r8unorm", // Also used in WGSL
"reference",
"rg11b10f",
"rg16snorm",
"rg16unorm",
// "rg8snorm", // Also used in WGSL
// "rg8unorm", // Also used in WGSL
"rgb10a2",
"rgb9e5",
"rgba16snorm",
"rgba16unorm",
// "rgba8snorm", // Also used in WGSL
// "rgba8unorm", // Also used in WGSL
// "sampler", // Also used in WGSL
"short2",
"short3",
"short4",
"size_t",
"srgba8unorm",
"texture",
"texture1d",
"texture1d_array",
"texture2d",
"texture2d_array",
"texture2d_ms",
"texture2d_ms_array",
"texture3d",
"texture_buffer",
"texturecube",
"texturecube_array",
"thread",
"threadgroup",
"threadgroup_imageblock",
"uchar",
"uchar2",
"uchar3",
"uchar4",
"uint",
"uint16_t",
"uint2",
"uint3",
"uint32_t",
"uint4",
"uint64_t",
"uint8_t",
"ulong2",
"ulong3",
"ulong4",
// "uniform", // Also used in WGSL
"ushort",
"ushort2",
"ushort3",
"ushort4",
"vec",
"vertex"));
} // namespace } // namespace
} // namespace transform } // namespace transform
} // namespace tint } // namespace tint

View File

@ -57,18 +57,6 @@ ast::Function* Transform::CloneWithStatementsAtStart(
body, decos, ret_decos); body, decos, ret_decos);
} }
void Transform::RenameReservedKeywords(CloneContext* ctx,
const char* names[],
size_t count) {
ctx->ReplaceAll([=](Symbol in) {
auto name_in = ctx->src->Symbols().NameFor(in);
if (std::binary_search(names, names + count, name_in)) {
return ctx->dst->Symbols().New("tint_" + name_in);
}
return ctx->dst->Symbols().New(name_in);
});
}
ast::DecorationList Transform::RemoveDecorations( ast::DecorationList Transform::RemoveDecorations(
CloneContext* ctx, CloneContext* ctx,
const ast::DecorationList& in, const ast::DecorationList& in,

View File

@ -165,25 +165,6 @@ class Transform {
ast::Function* in, ast::Function* in,
ast::StatementList statements); ast::StatementList statements);
/// Registers a symbol renamer on `ctx` for any symbol that is found in the
/// list of reserved identifiers.
/// @param ctx the clone context
/// @param names the lexicographically sorted list of reserved identifiers
/// @param count the number of identifiers in the array `names`
static void RenameReservedKeywords(CloneContext* ctx,
const char* names[],
size_t count);
/// Registers a symbol renamer on `ctx` for any symbol that is found in the
/// list of reserved identifiers.
/// @param ctx the clone context
/// @param names the lexicographically sorted list of reserved identifiers
template <size_t N>
static void RenameReservedKeywords(CloneContext* ctx,
const char* (&names)[N]) {
RenameReservedKeywords(ctx, names, N);
}
/// Clones the decoration list `in`, removing decorations based on a filter. /// Clones the decoration list `in`, removing decorations based on a filter.
/// @param ctx the clone context /// @param ctx the clone context
/// @param in the decorations to clone /// @param in the decorations to clone

View File

@ -40,7 +40,7 @@ TEST_F(HlslGeneratorImplTest_Alias, EmitAlias_NameCollision) {
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_THAT(result(), HasSubstr(R"(typedef float tint_float; EXPECT_THAT(result(), HasSubstr(R"(typedef float tint_symbol;
)")); )"));
} }

View File

@ -60,7 +60,7 @@ TEST_F(HlslGeneratorImplTest_Function, Emit_Function_Name_Collision) {
gen.increment_indent(); gen.increment_indent();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_THAT(result(), HasSubstr(R"( void tint_GeometryShader() { EXPECT_THAT(result(), HasSubstr(R"( void tint_symbol() {
return; return;
})")); })"));
} }
@ -877,7 +877,7 @@ TEST_F(HlslGeneratorImplTest_Function,
GeneratorImpl& gen = SanitizeAndBuild(); GeneratorImpl& gen = SanitizeAndBuild();
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_EQ(result(), R"(void tint_GeometryShader() { EXPECT_EQ(result(), R"(void tint_symbol() {
return; return;
} }

View File

@ -42,7 +42,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsStorageWO1d: case ValidTextureOverload::kDimensionsStorageWO1d:
return { return {
R"(int tint_tmp; R"(int tint_tmp;
tint_texture.GetDimensions(tint_tmp); tint_symbol.GetDimensions(tint_tmp);
)", )",
"tint_tmp", "tint_tmp",
}; };
@ -52,14 +52,14 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsStorageWO2d: case ValidTextureOverload::kDimensionsStorageWO2d:
return { return {
R"(int2 tint_tmp; R"(int2 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y);
)", )",
"tint_tmp", "tint_tmp",
}; };
case ValidTextureOverload::kDimensionsMultisampled2d: case ValidTextureOverload::kDimensionsMultisampled2d:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.xy", "tint_tmp.xy",
}; };
@ -70,14 +70,14 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsStorageWO2dArray: case ValidTextureOverload::kDimensionsStorageWO2dArray:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.xy", "tint_tmp.xy",
}; };
case ValidTextureOverload::kDimensionsMultisampled2dArray: case ValidTextureOverload::kDimensionsMultisampled2dArray:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.xy", "tint_tmp.xy",
}; };
@ -86,7 +86,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsStorageWO3d: case ValidTextureOverload::kDimensionsStorageWO3d:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp", "tint_tmp",
}; };
@ -94,7 +94,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsDepthCube: case ValidTextureOverload::kDimensionsDepthCube:
return { return {
R"(int2 tint_tmp; R"(int2 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y);
)", )",
"tint_tmp.xyy", "tint_tmp.xyy",
}; };
@ -102,7 +102,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsDepthCubeArray: case ValidTextureOverload::kDimensionsDepthCubeArray:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.xyy", "tint_tmp.xyy",
}; };
@ -110,7 +110,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsDepth2dLevel: case ValidTextureOverload::kDimensionsDepth2dLevel:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.xy", "tint_tmp.xy",
}; };
@ -118,14 +118,14 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsDepth2dArrayLevel: case ValidTextureOverload::kDimensionsDepth2dArrayLevel:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.xy", "tint_tmp.xy",
}; };
case ValidTextureOverload::kDimensions3dLevel: case ValidTextureOverload::kDimensions3dLevel:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.xyz", "tint_tmp.xyz",
}; };
@ -133,7 +133,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsDepthCubeLevel: case ValidTextureOverload::kDimensionsDepthCubeLevel:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.xyy", "tint_tmp.xyy",
}; };
@ -141,7 +141,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kDimensionsDepthCubeArrayLevel: case ValidTextureOverload::kDimensionsDepthCubeArrayLevel:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(1, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.xyy", "tint_tmp.xyy",
}; };
@ -152,14 +152,14 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kNumLayersStorageWO2dArray: case ValidTextureOverload::kNumLayersStorageWO2dArray:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.z", "tint_tmp.z",
}; };
case ValidTextureOverload::kNumLayersMultisampled2dArray: case ValidTextureOverload::kNumLayersMultisampled2dArray:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.z", "tint_tmp.z",
}; };
@ -170,7 +170,7 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kNumLevelsDepthCube: case ValidTextureOverload::kNumLevelsDepthCube:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.z", "tint_tmp.z",
}; };
@ -181,168 +181,168 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kNumLevelsDepthCubeArray: case ValidTextureOverload::kNumLevelsDepthCubeArray:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(0, tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.w", "tint_tmp.w",
}; };
case ValidTextureOverload::kNumSamplesMultisampled2d: case ValidTextureOverload::kNumSamplesMultisampled2d:
return { return {
R"(int3 tint_tmp; R"(int3 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z);
)", )",
"tint_tmp.z", "tint_tmp.z",
}; };
case ValidTextureOverload::kNumSamplesMultisampled2dArray: case ValidTextureOverload::kNumSamplesMultisampled2dArray:
return { return {
R"(int4 tint_tmp; R"(int4 tint_tmp;
tint_texture.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w); tint_symbol.GetDimensions(tint_tmp.x, tint_tmp.y, tint_tmp.z, tint_tmp.w);
)", )",
"tint_tmp.w", "tint_tmp.w",
}; };
case ValidTextureOverload::kSample1dF32: case ValidTextureOverload::kSample1dF32:
return R"(tint_texture.Sample(tint_sampler, 1.0f))"; return R"(tint_symbol.Sample(tint_symbol_1, 1.0f))";
case ValidTextureOverload::kSample2dF32: case ValidTextureOverload::kSample2dF32:
return R"(tint_texture.Sample(tint_sampler, float2(1.0f, 2.0f)))"; return R"(tint_symbol.Sample(tint_symbol_1, float2(1.0f, 2.0f)))";
case ValidTextureOverload::kSample2dOffsetF32: case ValidTextureOverload::kSample2dOffsetF32:
return R"(tint_texture.Sample(tint_sampler, float2(1.0f, 2.0f), int2(3, 4)))"; return R"(tint_symbol.Sample(tint_symbol_1, float2(1.0f, 2.0f), int2(3, 4)))";
case ValidTextureOverload::kSample2dArrayF32: case ValidTextureOverload::kSample2dArrayF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, float(3))))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3))))";
case ValidTextureOverload::kSample2dArrayOffsetF32: case ValidTextureOverload::kSample2dArrayOffsetF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
case ValidTextureOverload::kSample3dF32: case ValidTextureOverload::kSample3dF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSample3dOffsetF32: case ValidTextureOverload::kSample3dOffsetF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), int3(4, 5, 6)))";
case ValidTextureOverload::kSampleCubeF32: case ValidTextureOverload::kSampleCubeF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSampleCubeArrayF32: case ValidTextureOverload::kSampleCubeArrayF32:
return R"(tint_texture.Sample(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(4))))"; return R"(tint_symbol.Sample(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4))))";
case ValidTextureOverload::kSampleDepth2dF32: case ValidTextureOverload::kSampleDepth2dF32:
return R"(tint_texture.Sample(tint_sampler, float2(1.0f, 2.0f)))"; return R"(tint_symbol.Sample(tint_symbol_1, float2(1.0f, 2.0f)))";
case ValidTextureOverload::kSampleDepth2dOffsetF32: case ValidTextureOverload::kSampleDepth2dOffsetF32:
return R"(tint_texture.Sample(tint_sampler, float2(1.0f, 2.0f), int2(3, 4)))"; return R"(tint_symbol.Sample(tint_symbol_1, float2(1.0f, 2.0f), int2(3, 4)))";
case ValidTextureOverload::kSampleDepth2dArrayF32: case ValidTextureOverload::kSampleDepth2dArrayF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, float(3))))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3))))";
case ValidTextureOverload::kSampleDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleDepth2dArrayOffsetF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, float(3)), int2(4, 5)))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, float(3)), int2(4, 5)))";
case ValidTextureOverload::kSampleDepthCubeF32: case ValidTextureOverload::kSampleDepthCubeF32:
return R"(tint_texture.Sample(tint_sampler, float3(1.0f, 2.0f, 3.0f)))"; return R"(tint_symbol.Sample(tint_symbol_1, float3(1.0f, 2.0f, 3.0f)))";
case ValidTextureOverload::kSampleDepthCubeArrayF32: case ValidTextureOverload::kSampleDepthCubeArrayF32:
return R"(tint_texture.Sample(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(4))))"; return R"(tint_symbol.Sample(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4))))";
case ValidTextureOverload::kSampleBias2dF32: case ValidTextureOverload::kSampleBias2dF32:
return R"(tint_texture.SampleBias(tint_sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleBias2dOffsetF32: case ValidTextureOverload::kSampleBias2dOffsetF32:
return R"(tint_texture.SampleBias(tint_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleBias2dArrayF32: case ValidTextureOverload::kSampleBias2dArrayF32:
return R"(tint_texture.SampleBias(tint_sampler, float3(1.0f, 2.0f, float(4)), 3.0f))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, float(4)), 3.0f))";
case ValidTextureOverload::kSampleBias2dArrayOffsetF32: case ValidTextureOverload::kSampleBias2dArrayOffsetF32:
return R"(tint_texture.SampleBias(tint_sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleBias3dF32: case ValidTextureOverload::kSampleBias3dF32:
return R"(tint_texture.SampleBias(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleBias3dOffsetF32: case ValidTextureOverload::kSampleBias3dOffsetF32:
return R"(tint_texture.SampleBias(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
case ValidTextureOverload::kSampleBiasCubeF32: case ValidTextureOverload::kSampleBiasCubeF32:
return R"(tint_texture.SampleBias(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleBiasCubeArrayF32: case ValidTextureOverload::kSampleBiasCubeArrayF32:
return R"(tint_texture.SampleBias(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(3)), 4.0f))"; return R"(tint_symbol.SampleBias(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(3)), 4.0f))";
case ValidTextureOverload::kSampleLevel2dF32: case ValidTextureOverload::kSampleLevel2dF32:
return R"(tint_texture.SampleLevel(tint_sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleLevel2dOffsetF32: case ValidTextureOverload::kSampleLevel2dOffsetF32:
return R"(tint_texture.SampleLevel(tint_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleLevel2dArrayF32: case ValidTextureOverload::kSampleLevel2dArrayF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, float(3)), 4.0f))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4.0f))";
case ValidTextureOverload::kSampleLevel2dArrayOffsetF32: case ValidTextureOverload::kSampleLevel2dArrayOffsetF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleLevel3dF32: case ValidTextureOverload::kSampleLevel3dF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleLevel3dOffsetF32: case ValidTextureOverload::kSampleLevel3dOffsetF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f, int3(5, 6, 7)))";
case ValidTextureOverload::kSampleLevelCubeF32: case ValidTextureOverload::kSampleLevelCubeF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleLevelCubeArrayF32: case ValidTextureOverload::kSampleLevelCubeArrayF32:
return R"(tint_texture.SampleLevel(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
case ValidTextureOverload::kSampleLevelDepth2dF32: case ValidTextureOverload::kSampleLevelDepth2dF32:
return R"(tint_texture.SampleLevel(tint_sampler, float2(1.0f, 2.0f), 3))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3))";
case ValidTextureOverload::kSampleLevelDepth2dOffsetF32: case ValidTextureOverload::kSampleLevelDepth2dOffsetF32:
return R"(tint_texture.SampleLevel(tint_sampler, float2(1.0f, 2.0f), 3, int2(4, 5)))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float2(1.0f, 2.0f), 3, int2(4, 5)))";
case ValidTextureOverload::kSampleLevelDepth2dArrayF32: case ValidTextureOverload::kSampleLevelDepth2dArrayF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, float(3)), 4))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4))";
case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleLevelDepth2dArrayOffsetF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, float(3)), 4, int2(5, 6)))";
case ValidTextureOverload::kSampleLevelDepthCubeF32: case ValidTextureOverload::kSampleLevelDepthCubeF32:
return R"(tint_texture.SampleLevel(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4))";
case ValidTextureOverload::kSampleLevelDepthCubeArrayF32: case ValidTextureOverload::kSampleLevelDepthCubeArrayF32:
return R"(tint_texture.SampleLevel(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5))"; return R"(tint_symbol.SampleLevel(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), 5))";
case ValidTextureOverload::kSampleGrad2dF32: case ValidTextureOverload::kSampleGrad2dF32:
return R"(tint_texture.SampleGrad(tint_sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f)))";
case ValidTextureOverload::kSampleGrad2dOffsetF32: case ValidTextureOverload::kSampleGrad2dOffsetF32:
return R"(tint_texture.SampleGrad(tint_sampler, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f), int2(7, 8)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float2(1.0f, 2.0f), float2(3.0f, 4.0f), float2(5.0f, 6.0f), int2(7, 8)))";
case ValidTextureOverload::kSampleGrad2dArrayF32: case ValidTextureOverload::kSampleGrad2dArrayF32:
return R"(tint_texture.SampleGrad(tint_sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f)))";
case ValidTextureOverload::kSampleGrad2dArrayOffsetF32: case ValidTextureOverload::kSampleGrad2dArrayOffsetF32:
return R"(tint_texture.SampleGrad(tint_sampler, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(8, 9)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, float(3)), float2(4.0f, 5.0f), float2(6.0f, 7.0f), int2(8, 9)))";
case ValidTextureOverload::kSampleGrad3dF32: case ValidTextureOverload::kSampleGrad3dF32:
return R"(tint_texture.SampleGrad(tint_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
case ValidTextureOverload::kSampleGrad3dOffsetF32: case ValidTextureOverload::kSampleGrad3dOffsetF32:
return R"(tint_texture.SampleGrad(tint_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f), int3(10, 11, 12)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f), int3(10, 11, 12)))";
case ValidTextureOverload::kSampleGradCubeF32: case ValidTextureOverload::kSampleGradCubeF32:
return R"(tint_texture.SampleGrad(tint_sampler, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f), float3(7.0f, 8.0f, 9.0f)))";
case ValidTextureOverload::kSampleGradCubeArrayF32: case ValidTextureOverload::kSampleGradCubeArrayF32:
return R"(tint_texture.SampleGrad(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f)))"; return R"(tint_symbol.SampleGrad(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), float3(5.0f, 6.0f, 7.0f), float3(8.0f, 9.0f, 10.0f)))";
case ValidTextureOverload::kSampleCompareDepth2dF32: case ValidTextureOverload::kSampleCompareDepth2dF32:
return R"(tint_texture.SampleCmpLevelZero(tint_sampler, float2(1.0f, 2.0f), 3.0f))"; return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float2(1.0f, 2.0f), 3.0f))";
case ValidTextureOverload::kSampleCompareDepth2dOffsetF32: case ValidTextureOverload::kSampleCompareDepth2dOffsetF32:
return R"(tint_texture.SampleCmpLevelZero(tint_sampler, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))"; return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float2(1.0f, 2.0f), 3.0f, int2(4, 5)))";
case ValidTextureOverload::kSampleCompareDepth2dArrayF32: case ValidTextureOverload::kSampleCompareDepth2dArrayF32:
return R"(tint_texture.SampleCmpLevelZero(tint_sampler, float3(1.0f, 2.0f, float(4)), 3.0f))"; return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float3(1.0f, 2.0f, float(4)), 3.0f))";
case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32: case ValidTextureOverload::kSampleCompareDepth2dArrayOffsetF32:
return R"(tint_texture.SampleCmpLevelZero(tint_sampler, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6)))"; return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float3(1.0f, 2.0f, float(4)), 3.0f, int2(5, 6)))";
case ValidTextureOverload::kSampleCompareDepthCubeF32: case ValidTextureOverload::kSampleCompareDepthCubeF32:
return R"(tint_texture.SampleCmpLevelZero(tint_sampler, float3(1.0f, 2.0f, 3.0f), 4.0f))"; return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float3(1.0f, 2.0f, 3.0f), 4.0f))";
case ValidTextureOverload::kSampleCompareDepthCubeArrayF32: case ValidTextureOverload::kSampleCompareDepthCubeArrayF32:
return R"(tint_texture.SampleCmpLevelZero(tint_sampler, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))"; return R"(tint_symbol.SampleCmpLevelZero(tint_symbol_1, float4(1.0f, 2.0f, 3.0f, float(4)), 5.0f))";
case ValidTextureOverload::kLoad1dLevelF32: case ValidTextureOverload::kLoad1dLevelF32:
return R"(tint_texture.Load(int2(1, 0), 3))"; return R"(tint_symbol.Load(int2(1, 0), 3))";
case ValidTextureOverload::kLoad1dLevelU32: case ValidTextureOverload::kLoad1dLevelU32:
return R"(tint_texture.Load(int2(1, 0), 3))"; return R"(tint_symbol.Load(int2(1, 0), 3))";
case ValidTextureOverload::kLoad1dLevelI32: case ValidTextureOverload::kLoad1dLevelI32:
return R"(tint_texture.Load(int2(1, 0), 3))"; return R"(tint_symbol.Load(int2(1, 0), 3))";
case ValidTextureOverload::kLoad2dLevelF32: case ValidTextureOverload::kLoad2dLevelF32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoad2dLevelU32: case ValidTextureOverload::kLoad2dLevelU32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoad2dLevelI32: case ValidTextureOverload::kLoad2dLevelI32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoad2dArrayLevelF32: case ValidTextureOverload::kLoad2dArrayLevelF32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad2dArrayLevelU32: case ValidTextureOverload::kLoad2dArrayLevelU32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad2dArrayLevelI32: case ValidTextureOverload::kLoad2dArrayLevelI32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad3dLevelF32: case ValidTextureOverload::kLoad3dLevelF32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad3dLevelU32: case ValidTextureOverload::kLoad3dLevelU32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoad3dLevelI32: case ValidTextureOverload::kLoad3dLevelI32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadMultisampled2dF32: case ValidTextureOverload::kLoadMultisampled2dF32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadMultisampled2dU32: case ValidTextureOverload::kLoadMultisampled2dU32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadMultisampled2dI32: case ValidTextureOverload::kLoadMultisampled2dI32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadMultisampled2dArrayF32: case ValidTextureOverload::kLoadMultisampled2dArrayF32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadMultisampled2dArrayU32: case ValidTextureOverload::kLoadMultisampled2dArrayU32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadMultisampled2dArrayI32: case ValidTextureOverload::kLoadMultisampled2dArrayI32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadDepth2dLevelF32: case ValidTextureOverload::kLoadDepth2dLevelF32:
return R"(tint_texture.Load(int3(1, 2, 0), 3))"; return R"(tint_symbol.Load(int3(1, 2, 0), 3))";
case ValidTextureOverload::kLoadDepth2dArrayLevelF32: case ValidTextureOverload::kLoadDepth2dArrayLevelF32:
return R"(tint_texture.Load(int4(1, 2, 3, 0), 4))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0), 4))";
case ValidTextureOverload::kLoadStorageRO1dRgba32float: case ValidTextureOverload::kLoadStorageRO1dRgba32float:
return R"(tint_texture.Load(int2(1, 0)))"; return R"(tint_symbol.Load(int2(1, 0)))";
case ValidTextureOverload::kLoadStorageRO2dRgba8unorm: case ValidTextureOverload::kLoadStorageRO2dRgba8unorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8snorm: case ValidTextureOverload::kLoadStorageRO2dRgba8snorm:
case ValidTextureOverload::kLoadStorageRO2dRgba8uint: case ValidTextureOverload::kLoadStorageRO2dRgba8uint:
@ -359,19 +359,19 @@ ExpectedResult expected_texture_overload(
case ValidTextureOverload::kLoadStorageRO2dRgba32uint: case ValidTextureOverload::kLoadStorageRO2dRgba32uint:
case ValidTextureOverload::kLoadStorageRO2dRgba32sint: case ValidTextureOverload::kLoadStorageRO2dRgba32sint:
case ValidTextureOverload::kLoadStorageRO2dRgba32float: case ValidTextureOverload::kLoadStorageRO2dRgba32float:
return R"(tint_texture.Load(int3(1, 2, 0)))"; return R"(tint_symbol.Load(int3(1, 2, 0)))";
case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float: case ValidTextureOverload::kLoadStorageRO2dArrayRgba32float:
return R"(tint_texture.Load(int4(1, 2, 3, 0)))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kLoadStorageRO3dRgba32float: case ValidTextureOverload::kLoadStorageRO3dRgba32float:
return R"(tint_texture.Load(int4(1, 2, 3, 0)))"; return R"(tint_symbol.Load(int4(1, 2, 3, 0)))";
case ValidTextureOverload::kStoreWO1dRgba32float: case ValidTextureOverload::kStoreWO1dRgba32float:
return R"(tint_texture[1] = float4(2.0f, 3.0f, 4.0f, 5.0f))"; return R"(tint_symbol[1] = float4(2.0f, 3.0f, 4.0f, 5.0f))";
case ValidTextureOverload::kStoreWO2dRgba32float: case ValidTextureOverload::kStoreWO2dRgba32float:
return R"(tint_texture[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))"; return R"(tint_symbol[int2(1, 2)] = float4(3.0f, 4.0f, 5.0f, 6.0f))";
case ValidTextureOverload::kStoreWO2dArrayRgba32float: case ValidTextureOverload::kStoreWO2dArrayRgba32float:
return R"(tint_texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))"; return R"(tint_symbol[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
case ValidTextureOverload::kStoreWO3dRgba32float: case ValidTextureOverload::kStoreWO3dRgba32float:
return R"(tint_texture[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))"; return R"(tint_symbol[int3(1, 2, 3)] = float4(4.0f, 5.0f, 6.0f, 7.0f))";
} }
return "<unmatched texture overload>"; return "<unmatched texture overload>";
} // NOLINT - Ignore the length of this function } // NOLINT - Ignore the length of this function

View File

@ -236,8 +236,8 @@ TEST_F(HlslGeneratorImplTest_Type, EmitType_Struct_NameCollision) {
ASSERT_TRUE(gen.Generate(out)) << gen.error(); ASSERT_TRUE(gen.Generate(out)) << gen.error();
EXPECT_THAT(result(), HasSubstr(R"(struct S { EXPECT_THAT(result(), HasSubstr(R"(struct S {
int tint_double; int tint_symbol;
float tint_float; float tint_symbol_1;
}; };
)")); )"));
} }

View File

@ -21,6 +21,8 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "src/transform/hlsl.h" #include "src/transform/hlsl.h"
#include "src/transform/manager.h"
#include "src/transform/renamer.h"
#include "src/writer/hlsl/generator_impl.h" #include "src/writer/hlsl/generator_impl.h"
namespace tint { namespace tint {
@ -99,7 +101,13 @@ class TestHelperBase : public BODY, public ProgramBuilder {
<< formatter.format(program->Diagnostics()); << formatter.format(program->Diagnostics());
}(); }();
auto result = transform::Hlsl().Run(program.get()); transform::Manager transform_manager;
transform::Renamer::Config renamer_config{
transform::Renamer::Target::kHlslKeywords};
transform_manager.append(
std::make_unique<tint::transform::Renamer>(renamer_config));
transform_manager.append(std::make_unique<tint::transform::Hlsl>());
auto result = transform_manager.Run(program.get());
[&]() { [&]() {
ASSERT_TRUE(result.program.IsValid()) ASSERT_TRUE(result.program.IsValid())
<< formatter.format(result.program.Diagnostics()); << formatter.format(result.program.Diagnostics());