src/tint/lang/wgsl/reader/program_to_ir/shadowing_test.cc - dawn - Git at Google

 // 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.

 #include "gmock/gmock.h"
 #include "src/tint/lang/core/constant/scalar.h"
 #include "src/tint/lang/core/ir/block.h"
 #include "src/tint/lang/core/ir/constant.h"
 #include "src/tint/lang/core/ir/var.h"
 #include "src/tint/lang/wgsl/ast/case_selector.h"
 #include "src/tint/lang/wgsl/ast/int_literal_expression.h"
 #include "src/tint/lang/wgsl/helpers/ir_program_test.h"

 namespace tint::wgsl {
 namespace {

 using namespace tint::core::fluent_types;     // NOLINT
 using namespace tint::core::number_suffixes;  // NOLINT

 using ProgramToIRShadowingTest = helpers::IRProgramTest;

 ////////////////////////////////////////////////////////////////////////////////
 // Shadowing tests
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(ProgramToIRShadowingTest, Shadow_Struct_With_FnVar) {
     auto m = Build(R"(
 struct S {
   i : i32,
 }

 fn f() -> i32 {
   var S : S = S();
   return S.i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(S = struct @align(4) {
   i:i32 @offset(0)
 }

 %f = func():i32 -> %b1 {
   %b1 = block {
     %S:ptr<function, S, read_write> = var, S(0i)
     %3:ptr<function, i32, read_write> = access %S, 0u
     %4:i32 = load %3
     ret %4
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_Struct_With_Param) {
     auto m = Build(R"(
 struct S {
   i : i32,
 }

 fn f(S : S) -> i32 {
   return S.i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(S = struct @align(4) {
   i:i32 @offset(0)
 }

 %f = func(%S:S):i32 -> %b1 {
   %b1 = block {
     %3:i32 = access %S, 0u
     ret %3
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_ModVar_With_FnVar) {
     auto m = Build(R"(
 var<private> i : i32 = 1i;

 fn f() -> i32 {
   i = (i + 1i);
   var i : i32 = (i + 1i);
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
   %i:ptr<private, i32, read_write> = var, 1i
 }

 %f = func():i32 -> %b2 {
   %b2 = block {
     %3:i32 = load %i
     %4:i32 = add %3, 1i
     store %i, %4
     %5:i32 = load %i
     %6:i32 = add %5, 1i
     %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
     %8:i32 = load %i_1
     ret %8
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_ModVar_With_FnLet) {
     auto m = Build(R"(
 var<private> i : i32 = 1i;

 fn f() -> i32 {
   i = (i + 1i);
   let i = (i + 1i);
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
   %i:ptr<private, i32, read_write> = var, 1i
 }

 %f = func():i32 -> %b2 {
   %b2 = block {
     %3:i32 = load %i
     %4:i32 = add %3, 1i
     store %i, %4
     %5:i32 = load %i
     %6:i32 = add %5, 1i
     %i_1:i32 = let %6  # %i_1: 'i'
     ret %i_1
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_IfVar) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   if (true) {
     i = (i + 1i);
     var i : i32 = (i + 1i);
     i = (i + 1i);
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     if true [t: %b2] {  # if_1
       %b2 = block {  # true
         %3:i32 = load %i
         %4:i32 = add %3, 1i
         store %i, %4
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         %9:i32 = add %8, 1i
         store %i_1, %9
         exit_if  # if_1
       }
     }
     %10:i32 = load %i
     ret %10
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_IfLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   if (true) {
     i = (i + 1i);
     let i = (i + 1i);
     return i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     if true [t: %b2] {  # if_1
       %b2 = block {  # true
         %3:i32 = load %i
         %4:i32 = add %3, 1i
         store %i, %4
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         ret %i_1
       }
     }
     %8:i32 = load %i
     ret %8
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_WhileVar) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   while((i < 4i)) {
     var i : i32 = (i + 1i);
     return i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [b: %b2, c: %b3] {  # loop_1
       %b2 = block {  # body
         %3:i32 = load %i
         %4:bool = lt %3, 4i
         if %4 [t: %b4, f: %b5] {  # if_1
           %b4 = block {  # true
             exit_if  # if_1
           }
           %b5 = block {  # false
             exit_loop  # loop_1
           }
         }
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         ret %8
       }
       %b3 = block {  # continuing
         next_iteration %b2
       }
     }
     %9:i32 = load %i
     ret %9
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_WhileLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   while((i < 4i)) {
     let i = (i + 1i);
     return i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [b: %b2, c: %b3] {  # loop_1
       %b2 = block {  # body
         %3:i32 = load %i
         %4:bool = lt %3, 4i
         if %4 [t: %b4, f: %b5] {  # if_1
           %b4 = block {  # true
             exit_if  # if_1
           }
           %b5 = block {  # false
             exit_loop  # loop_1
           }
         }
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         ret %i_1
       }
       %b3 = block {  # continuing
         next_iteration %b2
       }
     }
     %8:i32 = load %i
     ret %8
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForInitVar) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   for(var i : f32 = 0.0f; (i < 4.0f); ) {
     let j = i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [i: %b2, b: %b3] {  # loop_1
       %b2 = block {  # initializer
         %i_1:ptr<function, f32, read_write> = var, 0.0f  # %i_1: 'i'
         next_iteration %b3
       }
       %b3 = block {  # body
         %4:f32 = load %i_1
         %5:bool = lt %4, 4.0f
         if %5 [t: %b4, f: %b5] {  # if_1
           %b4 = block {  # true
             exit_if  # if_1
           }
           %b5 = block {  # false
             exit_loop  # loop_1
           }
         }
         %6:f32 = load %i_1
         %j:f32 = let %6
         continue %b6
       }
     }
     %8:i32 = load %i
     ret %8
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForInitLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   for(let i = 0.0f; (i < 4.0f); ) {
     let j = i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [i: %b2, b: %b3] {  # loop_1
       %b2 = block {  # initializer
         %i_1:f32 = let 0.0f  # %i_1: 'i'
         next_iteration %b3
       }
       %b3 = block {  # body
         %4:bool = lt %i_1, 4.0f
         if %4 [t: %b4, f: %b5] {  # if_1
           %b4 = block {  # true
             exit_if  # if_1
           }
           %b5 = block {  # false
             exit_loop  # loop_1
           }
         }
         %j:f32 = let %i_1
         continue %b6
       }
     }
     %6:i32 = load %i
     ret %6
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForBodyVar) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   for(var x : i32 = 0i; (i < 4i); ) {
     var i : i32 = (i + 1i);
     return i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [i: %b2, b: %b3] {  # loop_1
       %b2 = block {  # initializer
         %x:ptr<function, i32, read_write> = var, 0i
         next_iteration %b3
       }
       %b3 = block {  # body
         %4:i32 = load %i
         %5:bool = lt %4, 4i
         if %5 [t: %b4, f: %b5] {  # if_1
           %b4 = block {  # true
             exit_if  # if_1
           }
           %b5 = block {  # false
             exit_loop  # loop_1
           }
         }
         %6:i32 = load %i
         %7:i32 = add %6, 1i
         %i_1:ptr<function, i32, read_write> = var, %7  # %i_1: 'i'
         %9:i32 = load %i_1
         ret %9
       }
     }
     %10:i32 = load %i
     ret %10
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForBodyLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   for(var x : i32 = 0i; (i < 4i); ) {
     let i = (i + 1i);
     return i;
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [i: %b2, b: %b3] {  # loop_1
       %b2 = block {  # initializer
         %x:ptr<function, i32, read_write> = var, 0i
         next_iteration %b3
       }
       %b3 = block {  # body
         %4:i32 = load %i
         %5:bool = lt %4, 4i
         if %5 [t: %b4, f: %b5] {  # if_1
           %b4 = block {  # true
             exit_if  # if_1
           }
           %b5 = block {  # false
             exit_loop  # loop_1
           }
         }
         %6:i32 = load %i
         %7:i32 = add %6, 1i
         %i_1:i32 = let %7  # %i_1: 'i'
         ret %i_1
       }
     }
     %9:i32 = load %i
     ret %9
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopBodyVar) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   loop {
     if ((i == 2i)) {
       break;
     }
     var i : i32 = (i + 1i);
     if ((i == 3i)) {
       break;
     }
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [b: %b2, c: %b3] {  # loop_1
       %b2 = block {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
         if %4 [t: %b4] {  # if_1
           %b4 = block {  # true
             exit_loop  # loop_1
           }
         }
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         %9:bool = eq %8, 3i
         if %9 [t: %b5] {  # if_2
           %b5 = block {  # true
             exit_loop  # loop_1
           }
         }
         continue %b3
       }
       %b3 = block {  # continuing
         next_iteration %b2
       }
     }
     %10:i32 = load %i
     ret %10
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopBodyLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   loop {
     if ((i == 2i)) {
       break;
     }
     let i = (i + 1i);
     if ((i == 3i)) {
       break;
     }
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [b: %b2, c: %b3] {  # loop_1
       %b2 = block {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
         if %4 [t: %b4] {  # if_1
           %b4 = block {  # true
             exit_loop  # loop_1
           }
         }
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         %8:bool = eq %i_1, 3i
         if %8 [t: %b5] {  # if_2
           %b5 = block {  # true
             exit_loop  # loop_1
           }
         }
         continue %b3
       }
       %b3 = block {  # continuing
         next_iteration %b2
       }
     }
     %9:i32 = load %i
     ret %9
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopContinuingVar) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   loop {
     if ((i == 2i)) {
       break;
     }

     continuing {
       var i : i32 = (i + 1i);
       break if (i > 2i);
     }
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [b: %b2, c: %b3] {  # loop_1
       %b2 = block {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
         if %4 [t: %b4] {  # if_1
           %b4 = block {  # true
             exit_loop  # loop_1
           }
         }
         continue %b3
       }
       %b3 = block {  # continuing
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         %9:bool = gt %8, 2i
         break_if %9 %b2
       }
     }
     %10:i32 = load %i
     ret %10
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopContinuingLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   loop {
     if ((i == 2i)) {
       break;
     }

     continuing {
       let i = (i + 1i);
       break if (i > 2i);
     }
   }
   return i;
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     loop [b: %b2, c: %b3] {  # loop_1
       %b2 = block {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
         if %4 [t: %b4] {  # if_1
           %b4 = block {  # true
             exit_loop  # loop_1
           }
         }
         continue %b3
       }
       %b3 = block {  # continuing
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         %8:bool = gt %i_1, 2i
         break_if %8 %b2
       }
     }
     %9:i32 = load %i
     ret %9
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_SwitchCaseVar) {
     auto m = Build(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;
     }
   }
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     %3:i32 = load %i
     switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] {  # switch_1
       %b2 = block {  # case
         %4:i32 = load %i
         ret %4
       }
       %b3 = block {  # case
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         ret %8
       }
       %b4 = block {  # case
         %9:i32 = load %i
         ret %9
       }
     }
     unreachable
   }
 }
 )");
 }

 TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_SwitchCaseLet) {
     auto m = Build(R"(
 fn f() -> i32 {
   var i : i32;
   switch(i) {
     case 0i: {
       return i;
     }
     case 1i: {
       let i = (i + 1i);
       return i;
     }
     default: {
       return i;
     }
   }
 }
 )");

     ASSERT_EQ(m, Success);

     EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
   %b1 = block {
     %i:ptr<function, i32, read_write> = var
     %3:i32 = load %i
     switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] {  # switch_1
       %b2 = block {  # case
         %4:i32 = load %i
         ret %4
       }
       %b3 = block {  # case
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         ret %i_1
       }
       %b4 = block {  # case
         %8:i32 = load %i
         ret %8
       }
     }
     unreachable
   }
 }
 )");
 }

 }  // namespace
 }  // namespace tint::wgsl
	// 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.

	#include "gmock/gmock.h"
	#include "src/tint/lang/core/constant/scalar.h"
	#include "src/tint/lang/core/ir/block.h"
	#include "src/tint/lang/core/ir/constant.h"
	#include "src/tint/lang/core/ir/var.h"
	#include "src/tint/lang/wgsl/ast/case_selector.h"
	#include "src/tint/lang/wgsl/ast/int_literal_expression.h"
	#include "src/tint/lang/wgsl/helpers/ir_program_test.h"

	namespace tint::wgsl {
	namespace {

	using namespace tint::core::fluent_types; // NOLINT
	using namespace tint::core::number_suffixes; // NOLINT

	using ProgramToIRShadowingTest = helpers::IRProgramTest;

	////////////////////////////////////////////////////////////////////////////////
	// Shadowing tests
	////////////////////////////////////////////////////////////////////////////////
	TEST_F(ProgramToIRShadowingTest, Shadow_Struct_With_FnVar) {
	auto m = Build(R"(
	struct S {
	i : i32,
	}

	fn f() -> i32 {
	var S : S = S();
	return S.i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(S = struct @align(4) {
	i:i32 @offset(0)
	}

	%f = func():i32 -> %b1 {
	%b1 = block {
	%S:ptr<function, S, read_write> = var, S(0i)
	%3:ptr<function, i32, read_write> = access %S, 0u
	%4:i32 = load %3
	ret %4
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_Struct_With_Param) {
	auto m = Build(R"(
	struct S {
	i : i32,
	}

	fn f(S : S) -> i32 {
	return S.i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(S = struct @align(4) {
	i:i32 @offset(0)
	}

	%f = func(%S:S):i32 -> %b1 {
	%b1 = block {
	%3:i32 = access %S, 0u
	ret %3
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_ModVar_With_FnVar) {
	auto m = Build(R"(
	var<private> i : i32 = 1i;

	fn f() -> i32 {
	i = (i + 1i);
	var i : i32 = (i + 1i);
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block { # root
	%i:ptr<private, i32, read_write> = var, 1i
	}

	%f = func():i32 -> %b2 {
	%b2 = block {
	%3:i32 = load %i
	%4:i32 = add %3, 1i
	store %i, %4
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i'
	%8:i32 = load %i_1
	ret %8
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_ModVar_With_FnLet) {
	auto m = Build(R"(
	var<private> i : i32 = 1i;

	fn f() -> i32 {
	i = (i + 1i);
	let i = (i + 1i);
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block { # root
	%i:ptr<private, i32, read_write> = var, 1i
	}

	%f = func():i32 -> %b2 {
	%b2 = block {
	%3:i32 = load %i
	%4:i32 = add %3, 1i
	store %i, %4
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:i32 = let %6 # %i_1: 'i'
	ret %i_1
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_IfVar) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	if (true) {
	i = (i + 1i);
	var i : i32 = (i + 1i);
	i = (i + 1i);
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	if true [t: %b2] { # if_1
	%b2 = block { # true
	%3:i32 = load %i
	%4:i32 = add %3, 1i
	store %i, %4
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i'
	%8:i32 = load %i_1
	%9:i32 = add %8, 1i
	store %i_1, %9
	exit_if # if_1
	}
	}
	%10:i32 = load %i
	ret %10
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_IfLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	if (true) {
	i = (i + 1i);
	let i = (i + 1i);
	return i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	if true [t: %b2] { # if_1
	%b2 = block { # true
	%3:i32 = load %i
	%4:i32 = add %3, 1i
	store %i, %4
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:i32 = let %6 # %i_1: 'i'
	ret %i_1
	}
	}
	%8:i32 = load %i
	ret %8
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_WhileVar) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	while((i < 4i)) {
	var i : i32 = (i + 1i);
	return i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [b: %b2, c: %b3] { # loop_1
	%b2 = block { # body
	%3:i32 = load %i
	%4:bool = lt %3, 4i
	if %4 [t: %b4, f: %b5] { # if_1
	%b4 = block { # true
	exit_if # if_1
	}
	%b5 = block { # false
	exit_loop # loop_1
	}
	}
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i'
	%8:i32 = load %i_1
	ret %8
	}
	%b3 = block { # continuing
	next_iteration %b2
	}
	}
	%9:i32 = load %i
	ret %9
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_WhileLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	while((i < 4i)) {
	let i = (i + 1i);
	return i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [b: %b2, c: %b3] { # loop_1
	%b2 = block { # body
	%3:i32 = load %i
	%4:bool = lt %3, 4i
	if %4 [t: %b4, f: %b5] { # if_1
	%b4 = block { # true
	exit_if # if_1
	}
	%b5 = block { # false
	exit_loop # loop_1
	}
	}
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:i32 = let %6 # %i_1: 'i'
	ret %i_1
	}
	%b3 = block { # continuing
	next_iteration %b2
	}
	}
	%8:i32 = load %i
	ret %8
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForInitVar) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	for(var i : f32 = 0.0f; (i < 4.0f); ) {
	let j = i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [i: %b2, b: %b3] { # loop_1
	%b2 = block { # initializer
	%i_1:ptr<function, f32, read_write> = var, 0.0f # %i_1: 'i'
	next_iteration %b3
	}
	%b3 = block { # body
	%4:f32 = load %i_1
	%5:bool = lt %4, 4.0f
	if %5 [t: %b4, f: %b5] { # if_1
	%b4 = block { # true
	exit_if # if_1
	}
	%b5 = block { # false
	exit_loop # loop_1
	}
	}
	%6:f32 = load %i_1
	%j:f32 = let %6
	continue %b6
	}
	}
	%8:i32 = load %i
	ret %8
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForInitLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	for(let i = 0.0f; (i < 4.0f); ) {
	let j = i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [i: %b2, b: %b3] { # loop_1
	%b2 = block { # initializer
	%i_1:f32 = let 0.0f # %i_1: 'i'
	next_iteration %b3
	}
	%b3 = block { # body
	%4:bool = lt %i_1, 4.0f
	if %4 [t: %b4, f: %b5] { # if_1
	%b4 = block { # true
	exit_if # if_1
	}
	%b5 = block { # false
	exit_loop # loop_1
	}
	}
	%j:f32 = let %i_1
	continue %b6
	}
	}
	%6:i32 = load %i
	ret %6
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForBodyVar) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	for(var x : i32 = 0i; (i < 4i); ) {
	var i : i32 = (i + 1i);
	return i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [i: %b2, b: %b3] { # loop_1
	%b2 = block { # initializer
	%x:ptr<function, i32, read_write> = var, 0i
	next_iteration %b3
	}
	%b3 = block { # body
	%4:i32 = load %i
	%5:bool = lt %4, 4i
	if %5 [t: %b4, f: %b5] { # if_1
	%b4 = block { # true
	exit_if # if_1
	}
	%b5 = block { # false
	exit_loop # loop_1
	}
	}
	%6:i32 = load %i
	%7:i32 = add %6, 1i
	%i_1:ptr<function, i32, read_write> = var, %7 # %i_1: 'i'
	%9:i32 = load %i_1
	ret %9
	}
	}
	%10:i32 = load %i
	ret %10
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_ForBodyLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	for(var x : i32 = 0i; (i < 4i); ) {
	let i = (i + 1i);
	return i;
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [i: %b2, b: %b3] { # loop_1
	%b2 = block { # initializer
	%x:ptr<function, i32, read_write> = var, 0i
	next_iteration %b3
	}
	%b3 = block { # body
	%4:i32 = load %i
	%5:bool = lt %4, 4i
	if %5 [t: %b4, f: %b5] { # if_1
	%b4 = block { # true
	exit_if # if_1
	}
	%b5 = block { # false
	exit_loop # loop_1
	}
	}
	%6:i32 = load %i
	%7:i32 = add %6, 1i
	%i_1:i32 = let %7 # %i_1: 'i'
	ret %i_1
	}
	}
	%9:i32 = load %i
	ret %9
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopBodyVar) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	loop {
	if ((i == 2i)) {
	break;
	}
	var i : i32 = (i + 1i);
	if ((i == 3i)) {
	break;
	}
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [b: %b2, c: %b3] { # loop_1
	%b2 = block { # body
	%3:i32 = load %i
	%4:bool = eq %3, 2i
	if %4 [t: %b4] { # if_1
	%b4 = block { # true
	exit_loop # loop_1
	}
	}
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i'
	%8:i32 = load %i_1
	%9:bool = eq %8, 3i
	if %9 [t: %b5] { # if_2
	%b5 = block { # true
	exit_loop # loop_1
	}
	}
	continue %b3
	}
	%b3 = block { # continuing
	next_iteration %b2
	}
	}
	%10:i32 = load %i
	ret %10
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopBodyLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	loop {
	if ((i == 2i)) {
	break;
	}
	let i = (i + 1i);
	if ((i == 3i)) {
	break;
	}
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [b: %b2, c: %b3] { # loop_1
	%b2 = block { # body
	%3:i32 = load %i
	%4:bool = eq %3, 2i
	if %4 [t: %b4] { # if_1
	%b4 = block { # true
	exit_loop # loop_1
	}
	}
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:i32 = let %6 # %i_1: 'i'
	%8:bool = eq %i_1, 3i
	if %8 [t: %b5] { # if_2
	%b5 = block { # true
	exit_loop # loop_1
	}
	}
	continue %b3
	}
	%b3 = block { # continuing
	next_iteration %b2
	}
	}
	%9:i32 = load %i
	ret %9
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopContinuingVar) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	loop {
	if ((i == 2i)) {
	break;
	}

	continuing {
	var i : i32 = (i + 1i);
	break if (i > 2i);
	}
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [b: %b2, c: %b3] { # loop_1
	%b2 = block { # body
	%3:i32 = load %i
	%4:bool = eq %3, 2i
	if %4 [t: %b4] { # if_1
	%b4 = block { # true
	exit_loop # loop_1
	}
	}
	continue %b3
	}
	%b3 = block { # continuing
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i'
	%8:i32 = load %i_1
	%9:bool = gt %8, 2i
	break_if %9 %b2
	}
	}
	%10:i32 = load %i
	ret %10
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_LoopContinuingLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	loop {
	if ((i == 2i)) {
	break;
	}

	continuing {
	let i = (i + 1i);
	break if (i > 2i);
	}
	}
	return i;
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	loop [b: %b2, c: %b3] { # loop_1
	%b2 = block { # body
	%3:i32 = load %i
	%4:bool = eq %3, 2i
	if %4 [t: %b4] { # if_1
	%b4 = block { # true
	exit_loop # loop_1
	}
	}
	continue %b3
	}
	%b3 = block { # continuing
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:i32 = let %6 # %i_1: 'i'
	%8:bool = gt %i_1, 2i
	break_if %8 %b2
	}
	}
	%9:i32 = load %i
	ret %9
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_SwitchCaseVar) {
	auto m = Build(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;
	}
	}
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	%3:i32 = load %i
	switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] { # switch_1
	%b2 = block { # case
	%4:i32 = load %i
	ret %4
	}
	%b3 = block { # case
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:ptr<function, i32, read_write> = var, %6 # %i_1: 'i'
	%8:i32 = load %i_1
	ret %8
	}
	%b4 = block { # case
	%9:i32 = load %i
	ret %9
	}
	}
	unreachable
	}
	}
	)");
	}

	TEST_F(ProgramToIRShadowingTest, Shadow_FnVar_With_SwitchCaseLet) {
	auto m = Build(R"(
	fn f() -> i32 {
	var i : i32;
	switch(i) {
	case 0i: {
	return i;
	}
	case 1i: {
	let i = (i + 1i);
	return i;
	}
	default: {
	return i;
	}
	}
	}
	)");

	ASSERT_EQ(m, Success);

	EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
	%b1 = block {
	%i:ptr<function, i32, read_write> = var
	%3:i32 = load %i
	switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] { # switch_1
	%b2 = block { # case
	%4:i32 = load %i
	ret %4
	}
	%b3 = block { # case
	%5:i32 = load %i
	%6:i32 = add %5, 1i
	%i_1:i32 = let %6 # %i_1: 'i'
	ret %i_1
	}
	%b4 = block { # case
	%8:i32 = load %i
	ret %8
	}
	}
	unreachable
	}
	}
	)");
	}

	} // namespace
	} // namespace tint::wgsl