| // Copyright 2023 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // GEN_BUILD:CONDITION(tint_build_wgsl_reader && tint_build_wgsl_writer) |
| |
| #include "gtest/gtest.h" |
| |
| #include "src/tint/lang/core/ir/disassembler.h" |
| #include "src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.h" |
| #include "src/tint/lang/wgsl/reader/reader.h" |
| #include "src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.h" |
| #include "src/tint/lang/wgsl/writer/raise/raise.h" |
| #include "src/tint/lang/wgsl/writer/writer.h" |
| #include "src/tint/utils/text/string.h" |
| |
| namespace tint::wgsl { |
| namespace { |
| |
| using namespace tint::core::number_suffixes; // NOLINT |
| |
| class IRToProgramRoundtripTest : public testing::Test { |
| public: |
| struct Result { |
| /// The resulting WGSL |
| std::string wgsl; |
| /// The resulting AST |
| std::string ast; |
| /// The resulting IR before raising |
| std::string ir_pre_raise; |
| /// The resulting IR after raising |
| std::string ir_post_raise; |
| /// The resulting error |
| std::string err; |
| /// The expected WGSL |
| std::string expected; |
| }; |
| |
| /// @return the round-tripped string and the expected string |
| Result Run(std::string input_wgsl, std::string expected_wgsl) { |
| std::string input{tint::TrimSpace(input_wgsl)}; |
| |
| Result result; |
| |
| wgsl::reader::Options options; |
| options.allowed_features = wgsl::AllowedFeatures::Everything(); |
| Source::File file("test.wgsl", std::string(input)); |
| auto ir_module = wgsl::reader::WgslToIR(&file, options); |
| if (ir_module != Success) { |
| return result; |
| } |
| |
| result.ir_pre_raise = core::ir::Disassembler(ir_module.Get()).Plain(); |
| |
| if (auto res = tint::wgsl::writer::Raise(ir_module.Get()); res != Success) { |
| result.err = res.Failure().reason.Str(); |
| return result; |
| } |
| |
| result.ir_post_raise = core::ir::Disassembler(ir_module.Get()).Plain(); |
| |
| writer::ProgramOptions program_options; |
| program_options.allowed_features = AllowedFeatures::Everything(); |
| auto output_program = wgsl::writer::IRToProgram(ir_module.Get(), program_options); |
| if (!output_program.IsValid()) { |
| result.err = output_program.Diagnostics().Str(); |
| result.ast = Program::printer(output_program); |
| return result; |
| } |
| |
| auto output = wgsl::writer::Generate(output_program, {}); |
| if (output != Success) { |
| std::stringstream ss; |
| ss << "wgsl::Generate() errored: " << output.Failure(); |
| result.err = ss.str(); |
| result.ast = Program::printer(output_program); |
| return result; |
| } |
| |
| result.expected = expected_wgsl.empty() ? input : tint::TrimSpace(expected_wgsl); |
| if (!result.expected.empty()) { |
| result.expected = "\n" + result.expected + "\n"; |
| } |
| |
| result.wgsl = std::string(tint::TrimSpace(output->wgsl)); |
| if (!result.wgsl.empty()) { |
| result.wgsl = "\n" + result.wgsl + "\n"; |
| } |
| |
| return result; |
| } |
| |
| Result Run(std::string wgsl) { return Run(wgsl, wgsl); } |
| }; |
| |
| std::ostream& operator<<(std::ostream& o, const IRToProgramRoundtripTest::Result& res) { |
| if (!res.err.empty()) { |
| o << "============================\n" |
| << "== Error ==\n" |
| << "============================\n" |
| << res.err << "\n\n"; |
| } |
| if (!res.ir_pre_raise.empty()) { |
| o << "============================\n" |
| << "== IR (pre-raise) ==\n" |
| << "============================\n" |
| << res.ir_pre_raise << "\n\n"; |
| } |
| if (!res.ir_post_raise.empty()) { |
| o << "============================\n" |
| << "== IR (post-raise) ==\n" |
| << "============================\n" |
| << res.ir_post_raise << "\n\n"; |
| } |
| if (!res.ast.empty()) { |
| o << "============================\n" |
| << "== AST ==\n" |
| << "============================\n" |
| << res.ast << "\n\n"; |
| } |
| return o; |
| } |
| |
| #define RUN_TEST(...) \ |
| do { \ |
| if (auto res = Run(__VA_ARGS__); res.err.empty()) { \ |
| EXPECT_EQ(res.expected, res.wgsl) << res; \ |
| } else { \ |
| FAIL() << res; \ |
| } \ |
| } while (false) |
| |
| TEST_F(IRToProgramRoundtripTest, EmptyModule) { |
| RUN_TEST(""); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, SingleFunction_Empty) { |
| RUN_TEST(R"( |
| fn f() { |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, SingleFunction_Return) { |
| RUN_TEST(R"( |
| fn f() { |
| return; |
| } |
| )", |
| R"( |
| fn f() { |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, SingleFunction_Return_i32) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| return 42i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, SingleFunction_Parameters) { |
| RUN_TEST(R"( |
| fn f(i : i32, u : u32) -> i32 { |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, SingleFunction_UnrestrictedPointerParameters) { |
| RUN_TEST(R"( |
| fn f(p : ptr<uniform, i32>) -> i32 { |
| return *(p); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Struct declaration |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, StructDecl_Scalars) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| b : u32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberAlign) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @align(32u) |
| b : u32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberSize) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @size(32u) |
| b : u32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberLocation) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @location(1u) |
| b : u32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberIndex) { |
| RUN_TEST(R"( |
| enable dual_source_blending; |
| |
| struct S { |
| a : i32, |
| @location(0u) @blend_src(0u) |
| b : u32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberBuiltin) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @builtin(position) |
| b : vec4<f32>, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberInterpolateType) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @location(1u) @interpolate(flat) |
| b : u32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberInterpolateTypeSampling) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @location(1u) @interpolate(perspective, centroid) |
| b : f32, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, StructDecl_MemberInvariant) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| @builtin(position) @invariant |
| b : vec4<f32>, |
| c : f32, |
| } |
| |
| var<private> v : S; |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Function Call |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, FnCall_NoArgs_NoRet) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn b() { |
| a(); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FnCall_NoArgs_Ret_i32) { |
| RUN_TEST(R"( |
| fn a() -> i32 { |
| return 1i; |
| } |
| |
| fn b() { |
| var i : i32 = a(); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FnCall_3Args_NoRet) { |
| RUN_TEST(R"( |
| fn a(x : i32, y : u32, z : f32) { |
| } |
| |
| fn b() { |
| a(1i, 2u, 3.0f); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FnCall_3Args_Ret_f32) { |
| RUN_TEST(R"( |
| fn a(x : i32, y : u32, z : f32) -> f32 { |
| return z; |
| } |
| |
| fn b() { |
| var v : f32 = a(1i, 2u, 3.0f); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FnCall_PtrArgs) { |
| RUN_TEST(R"( |
| var<private> y : i32 = 2i; |
| |
| fn a(px : ptr<function, i32>, py : ptr<private, i32>) -> i32 { |
| return (*(px) + *(py)); |
| } |
| |
| fn b() -> i32 { |
| var x : i32 = 1i; |
| return a(&(x), &(y)); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Core Builtin Call |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, CoreBuiltinCall_Stmt) { |
| RUN_TEST(R"( |
| fn f() { |
| workgroupBarrier(); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CoreBuiltinCall_Expr) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) { |
| var i : i32 = max(a, b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CoreBuiltinCall_PhonyAssignment) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) { |
| _ = max(a, b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CoreBuiltinCall_UnusedLet) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) { |
| let unused = max(a, b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CoreBuiltinCall_PtrArg) { |
| RUN_TEST(R"( |
| @group(0u) @binding(0u) var<storage, read> v : array<u32>; |
| |
| fn foo() -> u32 { |
| return arrayLength(&(v)); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CoreBuiltinCall_DisableDerivativeUniformity) { |
| RUN_TEST(R"( |
| fn f(in : f32) { |
| let x = dpdx(in); |
| let y = dpdy(in); |
| } |
| )", |
| R"( |
| diagnostic(off, derivative_uniformity); |
| |
| fn f(in : f32) { |
| let x = dpdx(in); |
| let y = dpdy(in); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Type Construct |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_i32) { |
| RUN_TEST(R"( |
| fn f(i : i32) { |
| var v : i32 = i32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_u32) { |
| RUN_TEST(R"( |
| fn f(i : u32) { |
| var v : u32 = u32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_f32) { |
| RUN_TEST(R"( |
| fn f(i : f32) { |
| var v : f32 = f32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_bool) { |
| RUN_TEST(R"( |
| fn f(i : bool) { |
| var v : bool = bool(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_struct) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| b : u32, |
| c : f32, |
| } |
| |
| fn f(a : i32, b : u32, c : f32) { |
| var v : S = S(a, b, c); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_array) { |
| RUN_TEST(R"( |
| fn f(i : i32) { |
| var v : array<i32, 3u> = array<i32, 3u>(i, i, i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_vec3i_Splat) { |
| RUN_TEST(R"( |
| fn f(i : i32) { |
| var v : vec3<i32> = vec3<i32>(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_vec3i_Scalars) { |
| RUN_TEST(R"( |
| fn f(i : i32) { |
| var v : vec3<i32> = vec3<i32>(i, i, i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_mat2x3f_Scalars) { |
| RUN_TEST(R"( |
| fn f(i : f32) { |
| var v : mat2x3<f32> = mat2x3<f32>(i, i, i, i, i, i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConstruct_mat2x3f_Columns) { |
| RUN_TEST(R"( |
| fn f(i : f32) { |
| var v : mat2x3<f32> = mat2x3<f32>(vec3<f32>(i, i, i), vec3<f32>(i, i, i)); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Type Convert |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_i32_to_u32) { |
| RUN_TEST(R"( |
| fn f(i : i32) { |
| var v : u32 = u32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_u32_to_f32) { |
| RUN_TEST(R"( |
| fn f(i : u32) { |
| var v : f32 = f32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_f32_to_i32) { |
| RUN_TEST(R"( |
| fn f(i : f32) { |
| var v : i32 = i32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_bool_to_u32) { |
| RUN_TEST(R"( |
| fn f(i : bool) { |
| var v : u32 = u32(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_vec3i_to_vec3u) { |
| RUN_TEST(R"( |
| fn f(i : vec3<i32>) { |
| var v : vec3<u32> = vec3<u32>(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_vec3u_to_vec3f) { |
| RUN_TEST(R"( |
| fn f(i : vec3<u32>) { |
| var v : vec3<f32> = vec3<f32>(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, TypeConvert_mat2x3f_to_mat2x3h) { |
| RUN_TEST(R"( |
| enable f16; |
| |
| fn f(i : mat2x3<f32>) { |
| var v : mat2x3<f16> = mat2x3<f16>(i); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Bitcast |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Bitcast_i32_to_u32) { |
| RUN_TEST(R"( |
| fn f(i : i32) { |
| var v : u32 = bitcast<u32>(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Bitcast_u32_to_f32) { |
| RUN_TEST(R"( |
| fn f(i : u32) { |
| var v : f32 = bitcast<f32>(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Bitcast_f32_to_i32) { |
| RUN_TEST(R"( |
| fn f(i : f32) { |
| var v : i32 = bitcast<i32>(i); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Discard |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Discard) { |
| RUN_TEST(R"( |
| fn f() { |
| discard; |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Access |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Access_Value_vec3f_1) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> f32 { |
| return v[1]; |
| } |
| )", |
| R"( |
| fn f(v : vec3<f32>) -> f32 { |
| return v.y; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_vec3f_1) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32>; |
| |
| fn f() -> f32 { |
| return v[1]; |
| } |
| )", |
| R"( |
| var<private> v : vec3<f32>; |
| |
| fn f() -> f32 { |
| return v.y; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_vec3f_z) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> f32 { |
| return v.z; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_vec3f_z) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32>; |
| |
| fn f() -> f32 { |
| return v.z; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_vec3f_g) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> f32 { |
| return v.g; |
| } |
| )", |
| R"( |
| fn f(v : vec3<f32>) -> f32 { |
| return v.y; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_vec3f_g) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32>; |
| |
| fn f() -> f32 { |
| return v.g; |
| } |
| )", |
| R"( |
| var<private> v : vec3<f32>; |
| |
| fn f() -> f32 { |
| return v.y; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_vec3f_i) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>, i : i32) -> f32 { |
| return v[i]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_vec3f_i) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32>; |
| |
| fn f(i : i32) -> f32 { |
| return v[i]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_mat3x2f_1_0) { |
| RUN_TEST(R"( |
| fn f(m : mat3x2<f32>) -> f32 { |
| return m[1][0]; |
| } |
| )", |
| R"( |
| fn f(m : mat3x2<f32>) -> f32 { |
| return m[1i].x; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_mat3x2f_1_0) { |
| RUN_TEST(R"( |
| var<private> m : mat3x2<f32>; |
| |
| fn f() -> f32 { |
| return m[1][0]; |
| } |
| )", |
| R"( |
| var<private> m : mat3x2<f32>; |
| |
| fn f() -> f32 { |
| return m[1i].x; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_mat3x2f_u_0) { |
| RUN_TEST(R"( |
| fn f(m : mat3x2<f32>, u : u32) -> f32 { |
| return m[u][0]; |
| } |
| )", |
| R"( |
| fn f(m : mat3x2<f32>, u : u32) -> f32 { |
| return m[u].x; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_mat3x2f_u_0) { |
| RUN_TEST(R"( |
| var<private> m : mat3x2<f32>; |
| |
| fn f(u : u32) -> f32 { |
| return m[u][0]; |
| } |
| )", |
| R"( |
| var<private> m : mat3x2<f32>; |
| |
| fn f(u : u32) -> f32 { |
| return m[u].x; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_mat3x2f_u_i) { |
| RUN_TEST(R"( |
| fn f(m : mat3x2<f32>, u : u32, i : i32) -> f32 { |
| return m[u][i]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_mat3x2f_u_i) { |
| RUN_TEST(R"( |
| var<private> m : mat3x2<f32>; |
| |
| fn f(u : u32, i : i32) -> f32 { |
| return m[u][i]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_array_0u) { |
| RUN_TEST(R"( |
| fn f(a : array<i32, 4u>) -> i32 { |
| return a[0u]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_array_0u) { |
| RUN_TEST(R"( |
| var<private> a : array<i32, 4u>; |
| |
| fn f() -> i32 { |
| return a[0u]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Value_array_i) { |
| RUN_TEST(R"( |
| fn f(a : array<i32, 4u>, i : i32) -> i32 { |
| return a[i]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Ref_array_i) { |
| RUN_TEST(R"( |
| var<private> a : array<i32, 4u>; |
| |
| fn f(i : i32) -> i32 { |
| return a[i]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ValueStruct) { |
| RUN_TEST(R"( |
| struct Y { |
| a : i32, |
| b : i32, |
| c : i32, |
| } |
| |
| struct X { |
| a : i32, |
| b : Y, |
| c : i32, |
| } |
| |
| fn f(x : X) -> i32 { |
| return x.b.c; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ReferenceStruct) { |
| RUN_TEST(R"( |
| struct Y { |
| a : i32, |
| b : i32, |
| c : i32, |
| } |
| |
| struct X { |
| a : i32, |
| b : Y, |
| c : i32, |
| } |
| |
| fn f() -> i32 { |
| var x : X; |
| return x.b.c; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfArrayOfArray_123) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> i32 { |
| var v_1 : array<array<array<i32, 3u>, 4u>, 5u>; |
| return v_1[a(1i)][a(2i)][a(3i)]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfArrayOfArray_213) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> i32 { |
| var v_1 : array<array<array<i32, 3u>, 4u>, 5u>; |
| let v_2 = a(2i); |
| return v_1[a(1i)][v_2][a(3i)]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfArrayOfArray_312) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> i32 { |
| var v_1 : array<array<array<i32, 3u>, 4u>, 5u>; |
| let v_2 = a(3i); |
| return v_1[a(1i)][a(2i)][v_2]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfArrayOfArray_321) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> i32 { |
| var v_1 : array<array<array<i32, 3u>, 4u>, 5u>; |
| let v_2 = a(3i); |
| let v_3 = a(2i); |
| return v_1[a(1i)][v_3][v_2]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfMat3x4f_123) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> f32 { |
| return array<mat3x4<f32>, 5u>()[a(1i)][a(2i)][a(3i)]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfMat3x4f_213) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> f32 { |
| let v_1 = array<mat3x4<f32>, 5u>(); |
| let v_2 = a(2i); |
| return v_1[a(1i)][v_2][a(3i)]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfMat3x4f_312) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> f32 { |
| let v_1 = array<mat3x4<f32>, 5u>(); |
| let v_2 = a(3i); |
| return v_1[a(1i)][a(2i)][v_2]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_ArrayOfMat3x4f_321) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> i32 { |
| return 1i; |
| } |
| |
| fn f() -> f32 { |
| let v_1 = array<mat3x4<f32>, 5u>(); |
| let v_2 = a(3i); |
| let v_3 = a(2i); |
| return v_1[a(1i)][v_3][v_2]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_UsePartialChains) { |
| RUN_TEST(R"( |
| var<private> a : array<array<array<i32, 4u>, 5u>, 6u>; |
| |
| fn f(i : i32) -> i32 { |
| let p1 = &(a[i]); |
| let p2 = &((*(p1))[i]); |
| let p3 = &((*(p2))[i]); |
| let v1 = *(p1); |
| let v2 = *(p2); |
| let v3 = *(p3); |
| return v3; |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Swizzle |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Value_xy) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> vec2<f32> { |
| return v.xy; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Value_yz) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> vec2<f32> { |
| return v.yz; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Value_yzx) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> vec3<f32> { |
| return v.yzx; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Value_yzxy) { |
| RUN_TEST(R"( |
| fn f(v : vec3<f32>) -> vec4<f32> { |
| return v.yzxy; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Pointer_xy) { |
| RUN_TEST(R"( |
| fn f(v : ptr<function, vec3<f32>>) -> vec2<f32> { |
| return (*(v)).xy; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Pointer_yz) { |
| RUN_TEST(R"( |
| fn f(v : ptr<function, vec3<f32>>) -> vec2<f32> { |
| return (*(v)).yz; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Pointer_yzx) { |
| RUN_TEST(R"( |
| fn f(v : ptr<function, vec3<f32>>) -> vec3<f32> { |
| return (*(v)).yzx; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Access_Vec3_Pointer_yzxy) { |
| RUN_TEST(R"( |
| fn f(v : ptr<function, vec3<f32>>) -> vec4<f32> { |
| return (*(v)).yzxy; |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Unary ops |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, UnaryOp_Negate) { |
| RUN_TEST(R"( |
| fn f(i : i32) -> i32 { |
| return -(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, UnaryOp_Complement) { |
| RUN_TEST(R"( |
| fn f(i : u32) -> u32 { |
| return ~(i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, UnaryOp_Not) { |
| RUN_TEST(R"( |
| fn f(b : bool) -> bool { |
| return !(b); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Binary ops |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Add) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a + b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Subtract) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a - b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Multiply) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a * b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Divide) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a / b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Modulo) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a % b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_And) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a & b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Or) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a | b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Xor) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> i32 { |
| return (a ^ b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_Equal) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> bool { |
| return (a == b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_NotEqual) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> bool { |
| return (a != b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_LessThan) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> bool { |
| return (a < b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_GreaterThan) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> bool { |
| return (a > b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_LessThanEqual) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> bool { |
| return (a <= b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_GreaterThanEqual) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : i32) -> bool { |
| return (a >= b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_ShiftLeft) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : u32) -> i32 { |
| return (a << b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, BinaryOp_ShiftRight) { |
| RUN_TEST(R"( |
| fn f(a : i32, b : u32) -> i32 { |
| return (a >> b); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Short-circuiting binary ops |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Param_2) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool) -> bool { |
| return (a && b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Param_3_ab_c) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| return ((a && b) && c); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Param_3_a_bc) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| return ((a && b) && c); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Let_2) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool) -> bool { |
| let l = (a && b); |
| return l; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Let_3_ab_c) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| let l = ((a && b) && c); |
| return l; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Let_3_a_bc) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| let l = (a && (b && c)); |
| return l; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Call_2) { |
| RUN_TEST(R"( |
| fn a() -> bool { |
| return true; |
| } |
| |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn f() -> bool { |
| return (a() && b()); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Call_3_ab_c) { |
| RUN_TEST(R"( |
| fn a() -> bool { |
| return true; |
| } |
| |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn c() -> bool { |
| return true; |
| } |
| |
| fn f() -> bool { |
| return ((a() && b()) && c()); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Call_3_a_bc) { |
| RUN_TEST(R"( |
| fn a() -> bool { |
| return true; |
| } |
| |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn c() -> bool { |
| return true; |
| } |
| |
| fn f() -> bool { |
| return (a() && (b() && c())); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Param_2) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool) -> bool { |
| return (a || b); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Param_3_ab_c) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| return ((a || b) || c); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Param_3_a_bc) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| return (a || (b || c)); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Let_2) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool) -> bool { |
| let l = (a || b); |
| return l; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Let_3_ab_c) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| let l = ((a || b) || c); |
| return l; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Let_3_a_bc) { |
| RUN_TEST(R"( |
| fn f(a : bool, b : bool, c : bool) -> bool { |
| let l = (a || (b || c)); |
| return l; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Call_2) { |
| RUN_TEST(R"( |
| fn a() -> bool { |
| return true; |
| } |
| |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn f() -> bool { |
| return (a() || b()); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Call_3_ab_c) { |
| RUN_TEST(R"( |
| fn a() -> bool { |
| return true; |
| } |
| |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn c() -> bool { |
| return true; |
| } |
| |
| fn f() -> bool { |
| return ((a() || b()) || c()); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Call_3_a_bc) { |
| RUN_TEST(R"( |
| fn a() -> bool { |
| return true; |
| } |
| |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn c() -> bool { |
| return true; |
| } |
| |
| fn f() -> bool { |
| return (a() || (b() || c())); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ShortCircuit_Mixed) { |
| RUN_TEST(R"( |
| fn b() -> bool { |
| return true; |
| } |
| |
| fn d() -> bool { |
| return true; |
| } |
| |
| fn f(a : bool, c : bool) -> bool { |
| let l = ((a || b()) && (c || d())); |
| return l; |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Assignment |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Assign_ArrayOfArrayOfArrayAccess_123456) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| v[e(1i)][e(2i)][e(3i)] = v[e(4i)][e(5i)][e(6i)]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Assign_ArrayOfArrayOfArrayAccess_261345) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_2 = e(2i); |
| let v_3 = e(6i); |
| v[e(1i)][v_2][e(3i)] = v[e(4i)][e(5i)][v_3]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Assign_ArrayOfArrayOfArrayAccess_532614) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_2 = e(5i); |
| let v_3 = e(3i); |
| let v_4 = e(2i); |
| let v_5 = e(6i); |
| v[e(1i)][v_4][v_3] = v[e(4i)][v_2][v_5]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Assign_ArrayOfMatrixAccess_123456) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| v[e(1i)][e(2i)][e(3i)] = v[e(4i)][e(5i)][e(6i)]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Assign_ArrayOfMatrixAccess_261345) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_2 = e(2i); |
| let v_3 = e(6i); |
| v[e(1i)][v_2][e(3i)] = v[e(4i)][e(5i)][v_3]; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Assign_ArrayOfMatrixAccess_532614) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_2 = e(5i); |
| let v_3 = e(3i); |
| let v_4 = e(2i); |
| let v_5 = e(6i); |
| v[e(1i)][v_4][v_3] = v[e(4i)][v_2][v_5]; |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Compound assignment |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Increment) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v++; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v + 1i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Decrement) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v++; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v + 1i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Add) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v += 8i; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v + 8i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Subtract) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v -= 8i; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v - 8i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Multiply) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v *= 8i; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v * 8i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Divide) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v /= 8i; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v / 8i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_Xor) { |
| RUN_TEST(R"( |
| fn f() { |
| var v : i32; |
| v ^= 8i; |
| } |
| )", |
| R"( |
| fn f() { |
| var v : i32; |
| v = (v ^ 8i); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_ArrayOfArrayOfArrayAccess_123456) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| v[e(1i)][e(2i)][e(3i)] += v[e(4i)][e(5i)][e(6i)]; |
| } |
| )", |
| R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_1 = &(v[e(1i)][e(2i)][e(3i)]); |
| let v_2 = v[e(4i)][e(5i)][e(6i)]; |
| *(v_1) = (*(v_1) + v_2); |
| })"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_ArrayOfArrayOfArrayAccess_261345) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_2 = e(2i); |
| let v_3 = e(6i); |
| v[e(1i)][v_2][e(3i)] += v[e(4i)][e(5i)][v_3]; |
| } |
| )", |
| R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_2 = e(2i); |
| let v_3 = e(6i); |
| let v_1 = &(v[e(1i)][v_2][e(3i)]); |
| let v_4 = v[e(4i)][e(5i)][v_3]; |
| *(v_1) = (*(v_1) + v_4); |
| })"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_ArrayOfArrayOfArrayAccess_532614) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_2 = e(5i); |
| let v_3 = e(3i); |
| let v_4 = e(2i); |
| let v_5 = e(6i); |
| v[e(1i)][v_4][v_3] += v[e(4i)][v_2][v_5]; |
| } |
| )", |
| R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<array<array<i32, 5u>, 5u>, 5u>; |
| let v_2 = e(5i); |
| let v_3 = e(3i); |
| let v_4 = e(2i); |
| let v_5 = e(6i); |
| let v_1 = &(v[e(1i)][v_4][v_3]); |
| let v_6 = v[e(4i)][v_2][v_5]; |
| *(v_1) = (*(v_1) + v_6); |
| })"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_ArrayOfMatrixAccess_123456) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| v[e(1i)][e(2i)][e(3i)] += v[e(4i)][e(5i)][e(6i)]; |
| } |
| )", |
| R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_1 = &(v[e(1i)][e(2i)]); |
| let v_2 = e(3i); |
| let v_3 = v[e(4i)][e(5i)][e(6i)]; |
| (*(v_1))[v_2] = ((*(v_1))[v_2] + v_3); |
| })"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_ArrayOfMatrixAccess_261345) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_2 = e(2i); |
| let v_3 = e(6i); |
| v[e(1i)][v_2][e(3i)] += v[e(4i)][e(5i)][v_3]; |
| } |
| )", |
| R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_2 = e(2i); |
| let v_3 = e(6i); |
| let v_1 = &(v[e(1i)][v_2]); |
| let v_4 = e(3i); |
| let v_5 = v[e(4i)][e(5i)][v_3]; |
| (*(v_1))[v_4] = ((*(v_1))[v_4] + v_5); |
| })"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, CompoundAssign_ArrayOfMatrixAccess_532614) { |
| RUN_TEST(R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_2 = e(5i); |
| let v_3 = e(3i); |
| let v_4 = e(2i); |
| let v_5 = e(6i); |
| v[e(1i)][v_4][v_3] += v[e(4i)][v_2][v_5]; |
| } |
| )", |
| R"( |
| fn e(i : i32) -> i32 { |
| return i; |
| } |
| |
| fn f() { |
| var v : array<mat3x4<f32>, 5u>; |
| let v_2 = e(5i); |
| let v_3 = e(3i); |
| let v_4 = e(2i); |
| let v_5 = e(6i); |
| let v_1 = &(v[e(1i)][v_4]); |
| let v_6 = v[e(4i)][v_2][v_5]; |
| (*(v_1))[v_3] = ((*(v_1))[v_3] + v_6); |
| })"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Phony Assignment |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_PrivateVar) { |
| RUN_TEST(R"( |
| var<private> p : i32; |
| |
| fn f() { |
| _ = p; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_FunctionVar) { |
| RUN_TEST(R"( |
| fn f() { |
| var i : i32; |
| _ = i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_FunctionLet) { |
| RUN_TEST(R"( |
| fn f() { |
| let i : i32 = 42i; |
| _ = i; |
| } |
| )", |
| R"( |
| fn f() { |
| let i = 42i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_HandleVar) { |
| RUN_TEST(R"( |
| @group(0u) @binding(0u) var t : texture_2d<f32>; |
| |
| fn f() { |
| _ = t; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_Constant) { |
| RUN_TEST(R"( |
| fn f() { |
| _ = 42i; |
| } |
| )", |
| R"( |
| fn f() { |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_Call) { |
| RUN_TEST(R"( |
| fn v() -> i32 { |
| return 42; |
| } |
| |
| fn f() { |
| _ = v(); |
| } |
| )", |
| R"( |
| fn v() -> i32 { |
| return 42i; |
| } |
| |
| fn f() { |
| v(); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, PhonyAssign_Conversion) { |
| RUN_TEST(R"( |
| fn f() { |
| let i = 42i; |
| _ = u32(i); |
| } |
| )", |
| R"( |
| fn f() { |
| let i = 42i; |
| _ = u32(i); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // let |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, LetUsedOnce) { |
| RUN_TEST(R"( |
| fn f(i : u32) -> u32 { |
| let v = ~(i); |
| return v; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, LetUsedTwice) { |
| RUN_TEST(R"( |
| fn f(i : i32) -> i32 { |
| let v = (i * 2i); |
| return (v + v); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Module-scope var |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_i32) { |
| RUN_TEST(R"( |
| var<private> v : i32 = 1i; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_u32) { |
| RUN_TEST(R"( |
| var<private> v : u32 = 1u; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_f32) { |
| RUN_TEST(R"( |
| var<private> v : f32 = 1.0f; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_f16) { |
| RUN_TEST(R"( |
| enable f16; |
| |
| var<private> v : f16 = 1.0h; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_bool) { |
| RUN_TEST(R"( |
| var<private> v : bool = true; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_array_NoArgs) { |
| RUN_TEST(R"( |
| var<private> v : array<i32, 4u> = array<i32, 4u>(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_array_Zero) { |
| RUN_TEST(R"( |
| var<private> v : array<i32, 4u> = array<i32, 4u>(0i, 0i, 0i, 0i); |
| var<private> v : array<i32, 4u> = array<i32, 4u>(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_array_SameValue) { |
| RUN_TEST(R"( |
| var<private> v : array<i32, 4u> = array<i32, 4u>(4i, 4i, 4i, 4i); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_array_DifferentValues) { |
| RUN_TEST(R"( |
| var<private> v : array<i32, 4u> = array<i32, 4u>(1i, 2i, 3i, 4i); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_struct_NoArgs) { |
| RUN_TEST(R"( |
| struct S { |
| i : i32, |
| u : u32, |
| f : f32, |
| } |
| |
| var<private> s : S = S(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_struct_Zero) { |
| RUN_TEST(R"( |
| struct S { |
| i : i32, |
| u : u32, |
| f : f32, |
| } |
| |
| var<private> s : S = S(0i, 0u, 0f); |
| )", |
| R"( |
| struct S { |
| i : i32, |
| u : u32, |
| f : f32, |
| } |
| |
| var<private> s : S = S(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_struct_SameValue) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| b : i32, |
| c : i32, |
| } |
| |
| var<private> s : S = S(4i, 4i, 4i); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_struct_DifferentValues) { |
| RUN_TEST(R"( |
| struct S { |
| a : i32, |
| b : i32, |
| c : i32, |
| } |
| |
| var<private> s : S = S(1i, 2i, 3i); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_vec3f_NoArgs) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32> = vec3<f32>(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_vec3f_Zero) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32> = vec3<f32>(0f);", |
| "var<private> v : vec3<f32> = vec3<f32>(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_vec3f_Splat) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32> = vec3<f32>(1.0f); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_vec3f_Scalars) { |
| RUN_TEST(R"( |
| var<private> v : vec3<f32> = vec3<f32>(1.0f, 2.0f, 3.0f); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_mat2x3f_NoArgs) { |
| RUN_TEST(R"( |
| var<private> v : mat2x3<f32> = mat2x3<f32>(); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_mat2x3f_Scalars_SameValue) { |
| RUN_TEST(R"( |
| var<private> v : mat2x3<f32> = mat2x3<f32>(4.0f, 4.0f, 4.0f, 4.0f, 4.0f, 4.0f); |
| var<private> v : mat2x3<f32> = mat2x3<f32>(vec3<f32>(4.0f), vec3<f32>(4.0f)); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_mat2x3f_Scalars) { |
| RUN_TEST(R"( |
| var<private> v : mat2x3<f32> = mat2x3<f32>(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f); |
| var<private> v : mat2x3<f32> = mat2x3<f32>(vec3<f32>(1.0f, 2.0f, 3.0f), vec3<f32>(4.0f, 5.0f, 6.0f)); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_mat2x3f_Columns) { |
| RUN_TEST( |
| R"( |
| var<private> v : mat2x3<f32> = mat2x3<f32>(vec3<f32>(1.0f, 2.0f, 3.0f), vec3<f32>(4.0f, 5.0f, 6.0f)); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Private_mat2x3f_Columns_SameValue) { |
| RUN_TEST(R"( |
| var<private> v : mat2x3<f32> = mat2x3<f32>(vec3<f32>(4.0f, 4.0f, 4.0f), vec3<f32>(4.0f, 4.0f, 4.0f)); |
| var<private> v : mat2x3<f32> = mat2x3<f32>(vec3<f32>(4.0f), vec3<f32>(4.0f)); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Uniform_vec4i) { |
| RUN_TEST(R"( |
| @group(10u) @binding(20u) var<uniform> v : vec4<i32>; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_StorageRead_u32) { |
| RUN_TEST(R"( |
| @group(10u) @binding(20u) var<storage, read> v : u32; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_StorageReadWrite_i32) { |
| RUN_TEST(R"( |
| @group(10u) @binding(20u) var<storage, read_write> v : i32; |
| )"); |
| } |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Handle_Texture2D) { |
| RUN_TEST(R"( |
| @group(0u) @binding(0u) var t : texture_2d<f32>; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Handle_Sampler) { |
| RUN_TEST(R"( |
| @group(0u) @binding(0u) var s : sampler; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, ModuleScopeVar_Handle_SamplerCmp) { |
| RUN_TEST(R"( |
| @group(0u) @binding(0u) var s : sampler_comparison; |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Function-scope var |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, FunctionScopeVar_i32) { |
| RUN_TEST(R"( |
| fn f() { |
| var i : i32; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FunctionScopeVar_i32_InitLiteral) { |
| RUN_TEST(R"( |
| fn f() { |
| var i : i32 = 42i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FunctionScopeVar_Chained) { |
| RUN_TEST(R"( |
| fn f() { |
| var a : i32 = 42i; |
| var b : i32 = a; |
| var c : i32 = b; |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Function-scope let |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, FunctionScopeLet_i32) { |
| RUN_TEST(R"( |
| fn f(i : i32) -> i32 { |
| let a = (42i + i); |
| let b = (24i + i); |
| let c = (a + b); |
| return c; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FunctionScopeLet_ptr) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var a : array<i32, 3u>; |
| let b = &(a[1i]); |
| let c = *(b); |
| return c; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, FunctionScopeLet_NoConstEvalError) { |
| // Tests that 'a' and 'b' are preserved as a let. |
| // If their constant values were inlined, then the initializer for 'c' would be treated as a |
| // constant expression instead of the authored runtime expression. Evaluating '1 / 0' as a |
| // constant expression is a WGSL validation error. |
| RUN_TEST(R"( |
| fn f() { |
| let a = 1i; |
| let b = 0i; |
| let c = (a / b); |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // If |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, If_CallFn) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn f(cond : bool) { |
| if (cond) { |
| a(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_Return) { |
| RUN_TEST(R"( |
| fn f(cond : bool) { |
| if (cond) { |
| return; |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_Return_i32) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var cond : bool = true; |
| if (cond) { |
| return 42i; |
| } |
| return 10i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_CallFn_Else_CallFn) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn b() { |
| } |
| |
| fn f(cond : bool) { |
| if (cond) { |
| a(); |
| } else { |
| b(); |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_Return_f32_Else_Return_f32) { |
| RUN_TEST(R"( |
| fn f() -> f32 { |
| var cond : bool = true; |
| if (cond) { |
| return 1.0f; |
| } else { |
| return 2.0f; |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_Return_u32_Else_CallFn) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn b() { |
| } |
| |
| fn f() -> u32 { |
| var cond : bool = true; |
| if (cond) { |
| return 1u; |
| } else { |
| a(); |
| } |
| b(); |
| return 2u; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_CallFn_ElseIf_CallFn) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn b() { |
| } |
| |
| fn c() { |
| } |
| |
| fn f() { |
| var cond : bool = true; |
| if (cond) { |
| a(); |
| } else if (false) { |
| b(); |
| } |
| c(); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, If_Else_Chain) { |
| RUN_TEST(R"( |
| fn x(i : i32) -> bool { |
| return true; |
| } |
| |
| fn f(a : bool, b : bool, c : bool, d : bool) { |
| if (a) { |
| x(0i); |
| } else if (b) { |
| x(1i); |
| } else if (c) { |
| x(2i); |
| } else { |
| x(3i); |
| } |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Switch |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Switch_Default) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn f() { |
| var v : i32 = 42i; |
| switch(v) { |
| default: { |
| a(); |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Switch_3_Cases) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn b() { |
| } |
| |
| fn c() { |
| } |
| |
| fn f() { |
| var v : i32 = 42i; |
| switch(v) { |
| case 0i: { |
| a(); |
| } |
| case 1i, default: { |
| b(); |
| } |
| case 2i: { |
| c(); |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Switch_3_Cases_AllReturn) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn f() { |
| var v : i32 = 42i; |
| switch(v) { |
| case 0i: { |
| return; |
| } |
| case 1i, default: { |
| return; |
| } |
| case 2i: { |
| return; |
| } |
| } |
| a(); |
| } |
| )", |
| R"( |
| fn a() { |
| } |
| |
| fn f() { |
| var v : i32 = 42i; |
| switch(v) { |
| case 0i: { |
| return; |
| } |
| case 1i, default: { |
| return; |
| } |
| case 2i: { |
| return; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Switch_Nested) { |
| RUN_TEST(R"( |
| fn a() { |
| } |
| |
| fn b() { |
| } |
| |
| fn c() { |
| } |
| |
| fn f() { |
| var v1 : i32 = 42i; |
| var v2 : i32 = 24i; |
| switch(v1) { |
| case 0i: { |
| a(); |
| } |
| case 1i, default: { |
| switch(v2) { |
| case 0i: { |
| } |
| case 1i, default: { |
| return; |
| } |
| } |
| } |
| case 2i: { |
| c(); |
| } |
| } |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // For |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, For_Empty) { |
| RUN_TEST(R"( |
| fn f() { |
| for(var i : i32 = 0i; (i < 5i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_Empty_NoInit) { |
| RUN_TEST(R"( |
| fn f() { |
| var i : i32 = 0i; |
| for(; (i < 5i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_Empty_NoCond) { |
| RUN_TEST(R"( |
| fn f() { |
| for(var i : i32 = 0i; ; i = (i + 1i)) { |
| break; |
| } |
| } |
| )", |
| R"( |
| fn f() { |
| { |
| var i : i32 = 0i; |
| loop { |
| break; |
| |
| continuing { |
| i = (i + 1i); |
| } |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_Empty_NoCont) { |
| RUN_TEST(R"( |
| fn f() { |
| for(var i : i32 = 0i; (i < 5i); ) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_ComplexBody) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> bool { |
| return (v == 1i); |
| } |
| |
| fn f() -> i32 { |
| for(var i : i32 = 0i; (i < 5i); i = (i + 1i)) { |
| if (a(42i)) { |
| return 1i; |
| } else { |
| return 2i; |
| } |
| } |
| return 3i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_ComplexBody_NoInit) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> bool { |
| return (v == 1i); |
| } |
| |
| fn f() -> i32 { |
| var i : i32 = 0i; |
| for(; (i < 5i); i = (i + 1i)) { |
| if (a(42i)) { |
| return 1i; |
| } else { |
| return 2i; |
| } |
| } |
| return 3i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_ComplexBody_NoCond) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> bool { |
| return (v == 1i); |
| } |
| |
| fn f() -> i32 { |
| for(var i : i32 = 0i; ; i = (i + 1i)) { |
| if (a(42i)) { |
| return 1i; |
| } else { |
| return 2i; |
| } |
| } |
| } |
| )", |
| R"( |
| fn a(v : i32) -> bool { |
| return (v == 1i); |
| } |
| |
| fn f() -> i32 { |
| { |
| var i : i32 = 0i; |
| loop { |
| if (a(42i)) { |
| return 1i; |
| } else { |
| return 2i; |
| } |
| |
| continuing { |
| i = (i + 1i); |
| } |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_ComplexBody_NoCont) { |
| RUN_TEST(R"( |
| fn a(v : i32) -> bool { |
| return (v == 1i); |
| } |
| |
| fn f() -> i32 { |
| for(var i : i32 = 0i; (i < 5i); ) { |
| if (a(42i)) { |
| return 1i; |
| } else { |
| return 2i; |
| } |
| } |
| return 3i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_CallInInitCondCont) { |
| RUN_TEST(R"( |
| fn n(v : i32) -> i32 { |
| return (v + 1i); |
| } |
| |
| fn f() { |
| for(var i : i32 = n(0i); (i < n(1i)); i = n(i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_AssignAsInit) { |
| RUN_TEST(R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i = 0i; (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_CompoundAssignAsInit) { |
| RUN_TEST(R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i += 0i; (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )", |
| R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i = (i + 0i); (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_IncrementAsInit) { |
| RUN_TEST(R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i++; (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )", |
| R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i = (i + 1i); (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_DecrementAsInit) { |
| RUN_TEST(R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i--; (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )", |
| R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(i = (i - 1i); (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, For_CallAsInit) { |
| RUN_TEST(R"( |
| fn n() { |
| } |
| |
| fn f() { |
| var i : i32 = 0i; |
| for(n(); (i < 10i); i = (i + 1i)) { |
| } |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // While |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, While_Empty) { |
| RUN_TEST(R"( |
| fn f() { |
| while(true) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, While_Cond) { |
| RUN_TEST(R"( |
| fn f(cond : bool) { |
| while(cond) { |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, While_Break) { |
| RUN_TEST(R"( |
| fn f() { |
| while(true) { |
| break; |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, While_IfBreak) { |
| RUN_TEST(R"( |
| fn f(cond : bool) { |
| while(true) { |
| if (cond) { |
| break; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, While_IfReturn) { |
| RUN_TEST(R"( |
| fn f(cond : bool) { |
| while(true) { |
| if (cond) { |
| return; |
| } |
| } |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Loop |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Loop_Break) { |
| RUN_TEST(R"( |
| fn f() { |
| loop { |
| break; |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_IfBreak) { |
| RUN_TEST(R"( |
| fn f(cond : bool) { |
| loop { |
| if (cond) { |
| break; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_IfReturn) { |
| RUN_TEST(R"( |
| fn f(cond : bool) { |
| loop { |
| if (cond) { |
| return; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_IfContinuing) { |
| RUN_TEST(R"( |
| fn f() { |
| var cond : bool = false; |
| loop { |
| if (cond) { |
| return; |
| } |
| |
| continuing { |
| cond = true; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_VarsDeclaredOutsideAndInside) { |
| RUN_TEST(R"( |
| fn f() { |
| var b : i32 = 1i; |
| loop { |
| var a : i32 = 2i; |
| if ((a == b)) { |
| return; |
| } |
| |
| continuing { |
| b = (a + b); |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_BreakIf_EmptyBody) { |
| RUN_TEST(R"( |
| fn f() { |
| loop { |
| |
| continuing { |
| break if false; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_BreakIf_NotFalse) { |
| RUN_TEST(R"( |
| fn f() { |
| loop { |
| if (false) { |
| } else { |
| break; |
| } |
| |
| continuing { |
| break if !false; |
| } |
| } |
| } |
| )", |
| R"( |
| fn f() { |
| loop { |
| if (!(false)) { |
| break; |
| } |
| |
| continuing { |
| break if true; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_BreakIf_NotTrue) { |
| RUN_TEST(R"( |
| fn f() { |
| loop { |
| if (false) { |
| } else { |
| break; |
| } |
| |
| continuing { |
| break if !true; |
| } |
| } |
| } |
| )", |
| R"( |
| fn f() { |
| loop { |
| if (!(false)) { |
| break; |
| } |
| |
| continuing { |
| break if false; |
| } |
| } |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Loop_WithReturn) { |
| RUN_TEST(R"( |
| fn f() { |
| loop { |
| let i = 42i; |
| return; |
| } |
| } |
| )"); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Shadowing tests |
| //////////////////////////////////////////////////////////////////////////////// |
| TEST_F(IRToProgramRoundtripTest, Shadow_f32_With_Fn) { |
| RUN_TEST(R"( |
| fn f32() { |
| var v = mat4x4f(); |
| } |
| )", |
| R"( |
| fn f32_1() { |
| var v : mat4x4<f32> = mat4x4<f32>(); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_f32_With_Struct) { |
| RUN_TEST(R"( |
| struct f32 { |
| v : i32, |
| } |
| |
| fn f(s : f32) { |
| let f = vec2f(1.0f); |
| } |
| )", |
| R"( |
| struct f32_1 { |
| v : i32, |
| } |
| |
| fn f(s : f32_1) { |
| let f_1 = vec2<f32>(1.0f); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_f32_With_ModVar) { |
| RUN_TEST(R"( |
| var<private> f32 : vec2f = vec2f(0.0f, 1.0f); |
| )", |
| R"( |
| var<private> f32_1 : vec2<f32> = vec2<f32>(0.0f, 1.0f); |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_f32_With_ModVar2) { |
| RUN_TEST(R"( |
| var<private> f32 : i32 = 1i; |
| |
| var<private> v = vec2(1.0).x; |
| )", |
| R"( |
| var<private> f32_1 : i32 = 1i; |
| |
| var<private> v : f32 = 1.0f; |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_f32_With_Alias) { |
| RUN_TEST(R"( |
| alias f32 = i32; |
| |
| fn f() { |
| var v = vec3(1.0f, 2.0f, 3.0f); |
| } |
| )", |
| R"( |
| fn f() { |
| var v : vec3<f32> = vec3<f32>(1.0f, 2.0f, 3.0f); |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_Struct_With_FnVar) { |
| RUN_TEST(R"( |
| struct S { |
| i : i32, |
| } |
| |
| fn f() -> i32 { |
| var S : S = S(); |
| return S.i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_Struct_With_Param) { |
| RUN_TEST(R"( |
| struct S { |
| i : i32, |
| } |
| |
| fn f(S : S) -> i32 { |
| return S.i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_ModVar_With_FnVar) { |
| RUN_TEST(R"( |
| var<private> i : i32 = 1i; |
| |
| fn f() -> i32 { |
| i = (i + 1i); |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_ModVar_With_FnLet) { |
| RUN_TEST(R"( |
| var<private> i : i32 = 1i; |
| |
| fn f() -> i32 { |
| i = (i + 1i); |
| let i = (i + 1i); |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_IfVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| if (true) { |
| i = (i + 1i); |
| var i : i32 = (i + 1i); |
| i = (i + 1i); |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_IfLet) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| if (true) { |
| i = (i + 1i); |
| let i = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_WhileVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| while((i < 4i)) { |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_WhileLet) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| while((i < 4i)) { |
| let i = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_ForInitVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(var i : f32 = 0.0f; (i < 4.0f); ) { |
| let j = i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_ForInitLet) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(let i = 0.0f; (i < 4.0f); ) { |
| let j = i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_ForBodyVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(var x : i32 = 0i; (i < 4i); ) { |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_ForBodyLet) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| for(var x : i32 = 0i; (i < 4i); ) { |
| let i = (i + 1i); |
| return i; |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_LoopBodyVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| var i : i32 = (i + 1i); |
| if ((i == 3i)) { |
| break; |
| } |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_LoopBodyLet) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| let i = (i + 1i); |
| if ((i == 3i)) { |
| break; |
| } |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_LoopContinuingVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| |
| continuing { |
| var i : i32 = (i + 1i); |
| break if (i > 2i); |
| } |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_LoopContinuingLet) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| loop { |
| if ((i == 2i)) { |
| break; |
| } |
| |
| continuing { |
| let i = (i + 1i); |
| break if (i > 2i); |
| } |
| } |
| return i; |
| } |
| )"); |
| } |
| |
| TEST_F(IRToProgramRoundtripTest, Shadow_FnVar_With_SwitchCaseVar) { |
| RUN_TEST(R"( |
| fn f() -> i32 { |
| var i : i32; |
| switch(i) { |
| case 0i: { |
| return i; |
| } |
| case 1i: { |
| var i : i32 = (i + 1i); |
| return i; |
| } |
| default: { |
| return i; |
| } |
| } |
| } |
| )"); |
| } |
| |
|