// Copyright 2023 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/tint/ir/transform/merge_return.h"

#include <utility>

#include "src/tint/ir/transform/test_helper.h"

namespace tint::ir::transform {
namespace {

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

using IR_MergeReturnTest = TransformTest;

TEST_F(IR_MergeReturnTest, NoModify_SingleReturnInRootBlock) {
    auto* in = b.FunctionParam(ty.i32());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({in});

    b.With(func->Block(), [&] { b.Return(func, b.Add(ty.i32(), in, 1_i)); });

    auto* src = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    %3:i32 = add %2, 1i
    ret %3
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = src;

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, NoModify_SingleReturnInMergeBlock) {
    auto* in = b.FunctionParam(ty.i32());
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({in});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        ifelse->SetResults(b.InstructionResult(ty.i32()));
        b.With(ifelse->True(), [&] { b.ExitIf(ifelse, b.Add(ty.i32(), in, 1_i)); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse, b.Add(ty.i32(), in, 2_i)); });

        b.Return(func, ifelse->Result(0));
    });
    auto* src = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    %3:i32 = if %4 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        %5:i32 = add %2, 1i
        exit_if %5  # if_1
      }
      %b3 = block {  # false
        %6:i32 = add %2, 2i
        exit_if %6  # if_1
      }
    }
    ret %3
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = src;

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, NoModify_SingleReturnInNestedMergeBlock) {
    auto* in = b.FunctionParam(ty.i32());
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({in});

    b.With(func->Block(), [&] {
        auto* swtch = b.Switch(in);
        b.With(b.Case(swtch, {Switch::CaseSelector{}}), [&] { b.ExitSwitch(swtch); });

        auto* l = b.Loop();
        b.With(l->Body(), [&] { b.ExitLoop(l); });

        auto* ifelse = b.If(cond);
        ifelse->SetResults(b.InstructionResult(ty.i32()));
        b.With(ifelse->True(), [&] { b.ExitIf(ifelse, b.Add(ty.i32(), in, 1_i)); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse, b.Add(ty.i32(), in, 2_i)); });

        b.Return(func, ifelse->Result(0));
    });

    auto* src = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    switch %2 [c: (default, %b2)] {  # switch_1
      %b2 = block {  # case
        exit_switch  # switch_1
      }
    }
    loop [b: %b3] {  # loop_1
      %b3 = block {  # body
        exit_loop  # loop_1
      }
    }
    %3:i32 = if %4 [t: %b4, f: %b5] {  # if_1
      %b4 = block {  # true
        %5:i32 = add %2, 1i
        exit_if %5  # if_1
      }
      %b5 = block {  # false
        %6:i32 = add %2, 2i
        exit_if %6  # if_1
      }
    }
    ret %3
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = src;

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_OneSideReturns) {
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.void_());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        b.With(ifelse->True(), [&] { b.Return(func); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

        b.Return(func);
    });

    auto* src = R"(
%foo = func(%2:bool):void -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        ret
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:bool):void -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        exit_if  # if_1
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    ret
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

// This is the same as the above tests, but we create the return instructions in a different order
// to make sure that creation order doesn't matter.
TEST_F(IR_MergeReturnTest, IfElse_OneSideReturns_ReturnsCreatedInDifferentOrder) {
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.void_());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        b.Return(func);

        b.With(ifelse->True(), [&] { b.Return(func); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });
    });

    auto* src = R"(
%foo = func(%2:bool):void -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        ret
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:bool):void -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        exit_if  # if_1
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    ret
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_OneSideReturns_WithValue) {
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        b.With(ifelse->True(), [&] { b.Return(func, 1_i); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

        b.Return(func, 2_i);
    });

    auto* src = R"(
%foo = func(%2:bool):i32 -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        ret 1i
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    ret 2i
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:bool):i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        store %continue_execution, false
        store %return_value, 1i
        exit_if  # if_1
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    %5:bool = load %continue_execution
    if %5 [t: %b4] {  # if_2
      %b4 = block {  # true
        store %return_value, 2i
        exit_if  # if_2
      }
    }
    %6:i32 = load %return_value
    ret %6
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_OneSideReturns_WithValue_MergeHasBasicBlockArguments) {
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        ifelse->SetResults(b.InstructionResult(ty.i32()));
        b.With(ifelse->True(), [&] { b.Return(func, 1_i); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse, 2_i); });

        b.Return(func, ifelse->Result(0));
    });

    auto* src = R"(
%foo = func(%2:bool):i32 -> %b1 {
  %b1 = block {
    %3:i32 = if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        ret 1i
      }
      %b3 = block {  # false
        exit_if 2i  # if_1
      }
    }
    ret %3
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:bool):i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    %5:i32 = if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        store %continue_execution, false
        store %return_value, 1i
        exit_if undef  # if_1
      }
      %b3 = block {  # false
        exit_if 2i  # if_1
      }
    }
    %6:bool = load %continue_execution
    if %6 [t: %b4] {  # if_2
      %b4 = block {  # true
        store %return_value, %5
        exit_if  # if_2
      }
    }
    %7:i32 = load %return_value
    ret %7
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_OneSideReturns_WithValue_MergeHasUndefBasicBlockArguments) {
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        ifelse->SetResults(b.InstructionResult(ty.i32()));
        b.With(ifelse->True(), [&] { b.Return(func, 1_i); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse, nullptr); });

        b.Return(func, ifelse->Result(0));
    });

    auto* src = R"(
%foo = func(%2:bool):i32 -> %b1 {
  %b1 = block {
    %3:i32 = if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        ret 1i
      }
      %b3 = block {  # false
        exit_if undef  # if_1
      }
    }
    ret %3
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:bool):i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    %5:i32 = if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        store %continue_execution, false
        store %return_value, 1i
        exit_if undef  # if_1
      }
      %b3 = block {  # false
        exit_if undef  # if_1
      }
    }
    %6:bool = load %continue_execution
    if %6 [t: %b4] {  # if_2
      %b4 = block {  # true
        store %return_value, %5
        exit_if  # if_2
      }
    }
    %7:i32 = load %return_value
    ret %7
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_BothSidesReturn) {
    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.void_());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        b.With(ifelse->True(), [&] { b.Return(func); });
        b.With(ifelse->False(), [&] { b.Return(func); });

        b.Unreachable();
    });

    auto* src = R"(
%foo = func(%2:bool):void -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        ret
      }
      %b3 = block {  # false
        ret
      }
    }
    unreachable
  }
}
)";

    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:bool):void -> %b1 {
  %b1 = block {
    if %2 [t: %b2, f: %b3] {  # if_1
      %b2 = block {  # true
        exit_if  # if_1
      }
      %b3 = block {  # false
        exit_if  # if_1
      }
    }
    ret
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_ThenStatements) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.void_());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        b.With(ifelse->True(), [&] { b.Return(func); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

        b.Store(global, 42_i);
        b.Return(func);
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):void -> %b2 {
  %b2 = block {
    if %3 [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        ret
      }
      %b4 = block {  # false
        exit_if  # if_1
      }
    }
    store %1, 42i
    ret
  }
}
)";

    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):void -> %b2 {
  %b2 = block {
    %continue_execution:ptr<function, bool, read_write> = var, true
    if %3 [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        store %continue_execution, false
        exit_if  # if_1
      }
      %b4 = block {  # false
        exit_if  # if_1
      }
    }
    %5:bool = load %continue_execution
    if %5 [t: %b5] {  # if_2
      %b5 = block {  # true
        store %1, 42i
        exit_if  # if_2
      }
    }
    ret
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

// This is the same as the above tests, but we create the return instructions in a different order
// to make sure that creation order doesn't matter.
TEST_F(IR_MergeReturnTest, IfElse_ThenStatements_ReturnsCreatedInDifferentOrder) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.void_());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* ifelse = b.If(cond);
        b.Store(global, 42_i);
        b.Return(func);

        b.With(ifelse->True(), [&] { b.Return(func); });
        b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):void -> %b2 {
  %b2 = block {
    if %3 [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        ret
      }
      %b4 = block {  # false
        exit_if  # if_1
      }
    }
    store %1, 42i
    ret
  }
}
)";

    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):void -> %b2 {
  %b2 = block {
    %continue_execution:ptr<function, bool, read_write> = var, true
    if %3 [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        store %continue_execution, false
        exit_if  # if_1
      }
      %b4 = block {  # false
        exit_if  # if_1
      }
    }
    %5:bool = load %continue_execution
    if %5 [t: %b5] {  # if_2
      %b5 = block {  # true
        store %1, 42i
        exit_if  # if_2
      }
    }
    ret
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_Nested) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* func = b.Function("foo", ty.i32());
    auto* condA = b.FunctionParam("condA", ty.bool_());
    auto* condB = b.FunctionParam("condB", ty.bool_());
    auto* condC = b.FunctionParam("condC", ty.bool_());
    func->SetParams({condA, condB, condC});

    b.With(func->Block(), [&] {
        auto* ifelse_outer = b.If(condA);
        b.With(ifelse_outer->True(), [&] { b.Return(func, 3_i); });
        b.With(ifelse_outer->False(), [&] {
            auto* ifelse_middle = b.If(condB);
            b.With(ifelse_middle->True(), [&] {
                auto* ifelse_inner = b.If(condC);
                b.With(ifelse_inner->True(), [&] { b.Return(func, 1_i); });
                b.With(ifelse_inner->False(), [&] { b.ExitIf(ifelse_inner); });

                b.Store(global, 1_i);
                b.Return(func, 2_i);
            });
            b.With(ifelse_middle->False(), [&] { b.ExitIf(ifelse_middle); });
            b.Store(global, 2_i);
            b.ExitIf(ifelse_outer);
        });
        b.Store(global, 3_i);
        b.Return(func, b.Add(ty.i32(), 5_i, 6_i));
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
  %b2 = block {
    if %condA [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        ret 3i
      }
      %b4 = block {  # false
        if %condB [t: %b5, f: %b6] {  # if_2
          %b5 = block {  # true
            if %condC [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                ret 1i
              }
              %b8 = block {  # false
                exit_if  # if_3
              }
            }
            store %1, 1i
            ret 2i
          }
          %b6 = block {  # false
            exit_if  # if_2
          }
        }
        store %1, 2i
        exit_if  # if_1
      }
    }
    store %1, 3i
    %6:i32 = add 5i, 6i
    ret %6
  }
}
)";

    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    if %condA [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        store %continue_execution, false
        store %return_value, 3i
        exit_if  # if_1
      }
      %b4 = block {  # false
        if %condB [t: %b5, f: %b6] {  # if_2
          %b5 = block {  # true
            if %condC [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                store %continue_execution, false
                store %return_value, 1i
                exit_if  # if_3
              }
              %b8 = block {  # false
                exit_if  # if_3
              }
            }
            %8:bool = load %continue_execution
            if %8 [t: %b9] {  # if_4
              %b9 = block {  # true
                store %1, 1i
                store %continue_execution, false
                store %return_value, 2i
                exit_if  # if_4
              }
            }
            exit_if  # if_2
          }
          %b6 = block {  # false
            exit_if  # if_2
          }
        }
        %9:bool = load %continue_execution
        if %9 [t: %b10] {  # if_5
          %b10 = block {  # true
            store %1, 2i
            exit_if  # if_5
          }
        }
        exit_if  # if_1
      }
    }
    %10:bool = load %continue_execution
    if %10 [t: %b11] {  # if_6
      %b11 = block {  # true
        store %1, 3i
        %11:i32 = add 5i, 6i
        store %return_value, %11
        exit_if  # if_6
      }
    }
    %12:i32 = load %return_value
    ret %12
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_Nested_TrivialMerge) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* func = b.Function("foo", ty.i32());
    auto* condA = b.FunctionParam("condA", ty.bool_());
    auto* condB = b.FunctionParam("condB", ty.bool_());
    auto* condC = b.FunctionParam("condC", ty.bool_());
    func->SetParams({condA, condB, condC});

    b.With(func->Block(), [&] {
        auto* ifelse_outer = b.If(condA);
        b.With(ifelse_outer->True(), [&] { b.Return(func, 3_i); });
        b.With(ifelse_outer->False(), [&] {
            auto* ifelse_middle = b.If(condB);
            b.With(ifelse_middle->True(), [&] {
                auto* ifelse_inner = b.If(condC);
                b.With(ifelse_inner->True(), [&] { b.Return(func, 1_i); });
                b.With(ifelse_inner->False(), [&] { b.ExitIf(ifelse_inner); });

                b.ExitIf(ifelse_middle);
            });
            b.With(ifelse_middle->False(), [&] { b.ExitIf(ifelse_middle); });

            b.ExitIf(ifelse_outer);
        });
        b.Return(func, 3_i);
    });
    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
  %b2 = block {
    if %condA [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        ret 3i
      }
      %b4 = block {  # false
        if %condB [t: %b5, f: %b6] {  # if_2
          %b5 = block {  # true
            if %condC [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                ret 1i
              }
              %b8 = block {  # false
                exit_if  # if_3
              }
            }
            exit_if  # if_2
          }
          %b6 = block {  # false
            exit_if  # if_2
          }
        }
        exit_if  # if_1
      }
    }
    ret 3i
  }
}
)";

    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    if %condA [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        store %continue_execution, false
        store %return_value, 3i
        exit_if  # if_1
      }
      %b4 = block {  # false
        if %condB [t: %b5, f: %b6] {  # if_2
          %b5 = block {  # true
            if %condC [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                store %continue_execution, false
                store %return_value, 1i
                exit_if  # if_3
              }
              %b8 = block {  # false
                exit_if  # if_3
              }
            }
            exit_if  # if_2
          }
          %b6 = block {  # false
            exit_if  # if_2
          }
        }
        exit_if  # if_1
      }
    }
    %8:bool = load %continue_execution
    if %8 [t: %b9] {  # if_4
      %b9 = block {  # true
        store %return_value, 3i
        exit_if  # if_4
      }
    }
    %9:i32 = load %return_value
    ret %9
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, IfElse_Nested_WithBasicBlockArguments) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* func = b.Function("foo", ty.i32());
    auto* condA = b.FunctionParam("condA", ty.bool_());
    auto* condB = b.FunctionParam("condB", ty.bool_());
    auto* condC = b.FunctionParam("condC", ty.bool_());
    func->SetParams({condA, condB, condC});

    b.With(func->Block(), [&] {
        auto* ifelse_outer = b.If(condA);
        ifelse_outer->SetResults(b.InstructionResult(ty.i32()));
        b.With(ifelse_outer->True(), [&] { b.Return(func, 3_i); });
        b.With(ifelse_outer->False(), [&] {
            auto* ifelse_middle = b.If(condB);
            ifelse_middle->SetResults(b.InstructionResult(ty.i32()));
            b.With(ifelse_middle->True(), [&] {
                auto* ifelse_inner = b.If(condC);

                b.With(ifelse_inner->True(), [&] { b.Return(func, 1_i); });
                b.With(ifelse_inner->False(), [&] { b.ExitIf(ifelse_inner); });

                b.ExitIf(ifelse_middle, b.Add(ty.i32(), 42_i, 1_i));
            });
            b.With(ifelse_middle->False(),
                   [&] { b.ExitIf(ifelse_middle, b.Add(ty.i32(), 43_i, 2_i)); });
            b.ExitIf(ifelse_outer, b.Add(ty.i32(), ifelse_middle->Result(0), 1_i));
        });

        b.Return(func, b.Add(ty.i32(), ifelse_outer->Result(0), 1_i));
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
  %b2 = block {
    %6:i32 = if %condA [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        ret 3i
      }
      %b4 = block {  # false
        %7:i32 = if %condB [t: %b5, f: %b6] {  # if_2
          %b5 = block {  # true
            if %condC [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                ret 1i
              }
              %b8 = block {  # false
                exit_if  # if_3
              }
            }
            %8:i32 = add 42i, 1i
            exit_if %8  # if_2
          }
          %b6 = block {  # false
            %9:i32 = add 43i, 2i
            exit_if %9  # if_2
          }
        }
        %10:i32 = add %7, 1i
        exit_if %10  # if_1
      }
    }
    %11:i32 = add %6, 1i
    ret %11
  }
}
)";

    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    %8:i32 = if %condA [t: %b3, f: %b4] {  # if_1
      %b3 = block {  # true
        store %continue_execution, false
        store %return_value, 3i
        exit_if undef  # if_1
      }
      %b4 = block {  # false
        %9:i32 = if %condB [t: %b5, f: %b6] {  # if_2
          %b5 = block {  # true
            if %condC [t: %b7, f: %b8] {  # if_3
              %b7 = block {  # true
                store %continue_execution, false
                store %return_value, 1i
                exit_if  # if_3
              }
              %b8 = block {  # false
                exit_if  # if_3
              }
            }
            %10:bool = load %continue_execution
            %11:i32 = if %10 [t: %b9] {  # if_4
              %b9 = block {  # true
                %12:i32 = add 42i, 1i
                exit_if %12  # if_4
              }
              # implicit false block: exit_if undef
            }
            exit_if %11  # if_2
          }
          %b6 = block {  # false
            %13:i32 = add 43i, 2i
            exit_if %13  # if_2
          }
        }
        %14:bool = load %continue_execution
        %15:i32 = if %14 [t: %b10] {  # if_5
          %b10 = block {  # true
            %16:i32 = add %9, 1i
            exit_if %16  # if_5
          }
          # implicit false block: exit_if undef
        }
        exit_if %15  # if_1
      }
    }
    %17:bool = load %continue_execution
    if %17 [t: %b11] {  # if_6
      %b11 = block {  # true
        %18:i32 = add %8, 1i
        store %return_value, %18
        exit_if  # if_6
      }
    }
    %19:i32 = load %return_value
    ret %19
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, Loop_UnconditionalReturnInBody) {
    auto* func = b.Function("foo", ty.i32());

    b.With(func->Block(), [&] {
        auto* loop = b.Loop();
        b.With(loop->Body(), [&] { b.Return(func, 42_i); });

        b.Unreachable();
    });
    auto* src = R"(
%foo = func():i32 -> %b1 {
  %b1 = block {
    loop [b: %b2] {  # loop_1
      %b2 = block {  # body
        ret 42i
      }
    }
    unreachable
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func():i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    loop [b: %b2] {  # loop_1
      %b2 = block {  # body
        store %return_value, 42i
        exit_loop  # loop_1
      }
    }
    %3:i32 = load %return_value
    ret %3
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, Loop_ConditionalReturnInBody) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* loop = b.Loop();
        b.With(loop->Body(), [&] {
            auto* ifelse = b.If(cond);
            b.With(ifelse->True(), [&] { b.Return(func, 42_i); });
            b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

            b.Store(global, 2_i);
            b.Continue(loop);
        });

        b.With(loop->Continuing(), [&] {
            b.Store(global, 1_i);
            b.BreakIf(loop, true);
        });

        b.Store(global, 3_i);
        b.Return(func, 43_i);
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):i32 -> %b2 {
  %b2 = block {
    loop [b: %b3, c: %b4] {  # loop_1
      %b3 = block {  # body
        if %3 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            ret 42i
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        store %1, 2i
        continue %b4
      }
      %b4 = block {  # continuing
        store %1, 1i
        break_if true %b3
      }
    }
    store %1, 3i
    ret 43i
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    loop [b: %b3, c: %b4] {  # loop_1
      %b3 = block {  # body
        if %3 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            store %continue_execution, false
            store %return_value, 42i
            exit_if  # if_1
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        %6:bool = load %continue_execution
        if %6 [t: %b7] {  # if_2
          %b7 = block {  # true
            store %1, 2i
            continue %b4
          }
        }
        exit_loop  # loop_1
      }
      %b4 = block {  # continuing
        store %1, 1i
        break_if true %b3
      }
    }
    %7:bool = load %continue_execution
    if %7 [t: %b8] {  # if_3
      %b8 = block {  # true
        store %1, 3i
        store %return_value, 43i
        exit_if  # if_3
      }
    }
    %8:i32 = load %return_value
    ret %8
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, Loop_ConditionalReturnInBody_UnreachableMerge) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* loop = b.Loop();
        b.With(loop->Body(), [&] {
            auto* ifelse = b.If(cond);

            b.With(ifelse->True(), [&] { b.Return(func, 42_i); });
            b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

            b.Store(global, 2_i);
            b.Continue(loop);
        });

        b.With(loop->Continuing(), [&] {
            b.Store(global, 1_i);
            b.NextIteration(loop);
        });

        b.Unreachable();
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):i32 -> %b2 {
  %b2 = block {
    loop [b: %b3, c: %b4] {  # loop_1
      %b3 = block {  # body
        if %3 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            ret 42i
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        store %1, 2i
        continue %b4
      }
      %b4 = block {  # continuing
        store %1, 1i
        next_iteration %b3
      }
    }
    unreachable
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    loop [b: %b3, c: %b4] {  # loop_1
      %b3 = block {  # body
        if %3 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            store %continue_execution, false
            store %return_value, 42i
            exit_if  # if_1
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        %6:bool = load %continue_execution
        if %6 [t: %b7] {  # if_2
          %b7 = block {  # true
            store %1, 2i
            continue %b4
          }
        }
        exit_loop  # loop_1
      }
      %b4 = block {  # continuing
        store %1, 1i
        next_iteration %b3
      }
    }
    %7:i32 = load %return_value
    ret %7
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, DISABLED_Loop_WithBasicBlockArgumentsOnMerge) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* cond = b.FunctionParam(ty.bool_());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* loop = b.Loop();
        loop->SetResults(b.InstructionResult(ty.i32()));
        b.With(loop->Body(), [&] {
            auto* ifelse = b.If(cond);
            b.With(ifelse->True(), [&] { b.Return(func, 42_i); });
            b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

            b.Store(global, 2_i);
            b.Continue(loop);
        });

        b.With(loop->Continuing(), [&] {
            b.Store(global, 1_i);
            b.BreakIf(loop, true, 4_i);
        });

        b.Store(global, 3_i);
        b.Return(func, loop->Result(0));
    });
    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):i32 -> %b2 {
  %b2 = block {
    %4:i32 = loop [b: %b3, c: %b4] {  # loop_1
      %b3 = block {  # body
        if %3 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            ret 42i
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        store %1, 2i
        continue %b4
      }
      %b4 = block {  # continuing
        store %1, 1i
        break_if true %b3 4i
      }
    }
    store %1, 3i
    ret %4
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:bool):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    %6:i32 = loop [b: %b3, c: %b4] {  # loop_1
      %b3 = block {  # body
        if %3 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            store %continue_execution, false
            store %return_value, 42i
            exit_if  # if_1
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        %7:bool = load %continue_execution
        if %7 [t: %b7] {  # if_2
          %b7 = block {  # true
            store %1, 2i
            continue %b4
          }
        }
        exit_loop  # loop_1
      }
      %b4 = block {  # continuing
        store %1, 1i
        break_if true %b3 4i
      }
    }
    %8:bool = load %continue_execution
    if %8 [t: %b8] {  # if_3
      %b8 = block {  # true
        store %1, 3i
        store %return_value, %6
        exit_if  # if_3
      }
    }
    %9:i32 = load %return_value
    ret %9
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, Switch_UnconditionalReturnInCase) {
    auto* cond = b.FunctionParam(ty.i32());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* sw = b.Switch(cond);
        b.With(b.Case(sw, {Switch::CaseSelector{b.Constant(1_i)}}), [&] { b.Return(func, 42_i); });
        b.With(b.Case(sw, {Switch::CaseSelector{}}), [&] { b.ExitSwitch(sw); });

        b.Return(func, 0_i);
    });

    auto* src = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    switch %2 [c: (1i, %b2), c: (default, %b3)] {  # switch_1
      %b2 = block {  # case
        ret 42i
      }
      %b3 = block {  # case
        exit_switch  # switch_1
      }
    }
    ret 0i
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    switch %2 [c: (1i, %b2), c: (default, %b3)] {  # switch_1
      %b2 = block {  # case
        store %continue_execution, false
        store %return_value, 42i
        exit_switch  # switch_1
      }
      %b3 = block {  # case
        exit_switch  # switch_1
      }
    }
    %5:bool = load %continue_execution
    if %5 [t: %b4] {  # if_1
      %b4 = block {  # true
        store %return_value, 0i
        exit_if  # if_1
      }
    }
    %6:i32 = load %return_value
    ret %6
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, Switch_ConditionalReturnInBody) {
    auto* global = b.Var(ty.ptr<private_, i32>());
    b.RootBlock()->Append(global);

    auto* cond = b.FunctionParam(ty.i32());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* sw = b.Switch(cond);
        b.With(b.Case(sw, {Switch::CaseSelector{b.Constant(1_i)}}), [&] {
            auto* ifcond = b.Equal(ty.bool_(), cond, 1_i);
            auto* ifelse = b.If(ifcond);
            b.With(ifelse->True(), [&] { b.Return(func, 42_i); });
            b.With(ifelse->False(), [&] { b.ExitIf(ifelse); });

            b.Store(global, 2_i);
            b.ExitSwitch(sw);
        });

        b.With(b.Case(sw, {Switch::CaseSelector{}}), [&] { b.ExitSwitch(sw); });

        b.Return(func, 0_i);
    });

    auto* src = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:i32):i32 -> %b2 {
  %b2 = block {
    switch %3 [c: (1i, %b3), c: (default, %b4)] {  # switch_1
      %b3 = block {  # case
        %4:bool = eq %3, 1i
        if %4 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            ret 42i
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        store %1, 2i
        exit_switch  # switch_1
      }
      %b4 = block {  # case
        exit_switch  # switch_1
      }
    }
    ret 0i
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%b1 = block {  # root
  %1:ptr<private, i32, read_write> = var
}

%foo = func(%3:i32):i32 -> %b2 {
  %b2 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    switch %3 [c: (1i, %b3), c: (default, %b4)] {  # switch_1
      %b3 = block {  # case
        %6:bool = eq %3, 1i
        if %6 [t: %b5, f: %b6] {  # if_1
          %b5 = block {  # true
            store %continue_execution, false
            store %return_value, 42i
            exit_if  # if_1
          }
          %b6 = block {  # false
            exit_if  # if_1
          }
        }
        %7:bool = load %continue_execution
        if %7 [t: %b7] {  # if_2
          %b7 = block {  # true
            store %1, 2i
            exit_switch  # switch_1
          }
        }
        exit_switch  # switch_1
      }
      %b4 = block {  # case
        exit_switch  # switch_1
      }
    }
    %8:bool = load %continue_execution
    if %8 [t: %b8] {  # if_3
      %b8 = block {  # true
        store %return_value, 0i
        exit_if  # if_3
      }
    }
    %9:i32 = load %return_value
    ret %9
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, Switch_WithBasicBlockArgumentsOnMerge) {
    auto* cond = b.FunctionParam(ty.i32());
    auto* func = b.Function("foo", ty.i32());
    func->SetParams({cond});

    b.With(func->Block(), [&] {
        auto* sw = b.Switch(cond);
        sw->SetResults(b.InstructionResult(ty.i32()));  // NOLINT: false detection of std::tuple
        b.With(b.Case(sw, {Switch::CaseSelector{b.Constant(1_i)}}), [&] { b.Return(func, 42_i); });
        b.With(b.Case(sw, {Switch::CaseSelector{b.Constant(2_i)}}), [&] { b.Return(func, 99_i); });
        b.With(b.Case(sw, {Switch::CaseSelector{b.Constant(3_i)}}), [&] { b.ExitSwitch(sw, 1_i); });
        b.With(b.Case(sw, {Switch::CaseSelector{}}), [&] { b.ExitSwitch(sw, 0_i); });

        b.Return(func, sw->Result(0));
    });

    auto* src = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    %3:i32 = switch %2 [c: (1i, %b2), c: (2i, %b3), c: (3i, %b4), c: (default, %b5)] {  # switch_1
      %b2 = block {  # case
        ret 42i
      }
      %b3 = block {  # case
        ret 99i
      }
      %b4 = block {  # case
        exit_switch 1i  # switch_1
      }
      %b5 = block {  # case
        exit_switch 0i  # switch_1
      }
    }
    ret %3
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func(%2:i32):i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    %5:i32 = switch %2 [c: (1i, %b2), c: (2i, %b3), c: (3i, %b4), c: (default, %b5)] {  # switch_1
      %b2 = block {  # case
        store %continue_execution, false
        store %return_value, 42i
        exit_switch undef  # switch_1
      }
      %b3 = block {  # case
        store %continue_execution, false
        store %return_value, 99i
        exit_switch undef  # switch_1
      }
      %b4 = block {  # case
        exit_switch 1i  # switch_1
      }
      %b5 = block {  # case
        exit_switch 0i  # switch_1
      }
    }
    %6:bool = load %continue_execution
    if %6 [t: %b6] {  # if_1
      %b6 = block {  # true
        store %return_value, %5
        exit_if  # if_1
      }
    }
    %7:i32 = load %return_value
    ret %7
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, LoopIfReturnThenContinue) {
    auto* func = b.Function("foo", ty.void_());

    b.With(func->Block(), [&] {
        auto* loop = b.Loop();
        b.With(loop->Body(), [&] {
            b.With(b.If(true)->True(), [&] { b.Return(func); });
            b.Continue(loop);
        });
        b.Unreachable();
    });

    auto* src = R"(
%foo = func():void -> %b1 {
  %b1 = block {
    loop [b: %b2] {  # loop_1
      %b2 = block {  # body
        if true [t: %b3] {  # if_1
          %b3 = block {  # true
            ret
          }
        }
        continue %b4
      }
    }
    unreachable
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func():void -> %b1 {
  %b1 = block {
    %continue_execution:ptr<function, bool, read_write> = var, true
    loop [b: %b2] {  # loop_1
      %b2 = block {  # body
        if true [t: %b3] {  # if_1
          %b3 = block {  # true
            store %continue_execution, false
            exit_if  # if_1
          }
        }
        %3:bool = load %continue_execution
        if %3 [t: %b4] {  # if_2
          %b4 = block {  # true
            continue %b5
          }
        }
        exit_loop  # loop_1
      }
    }
    ret
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

TEST_F(IR_MergeReturnTest, NestedIfsWithReturns) {
    auto* func = b.Function("foo", ty.i32());

    b.With(func->Block(), [&] {
        b.With(b.If(true)->True(), [&] {
            b.With(b.If(true)->True(), [&] { b.Return(func, 1_i); });
            b.Return(func, 2_i);
        });
        b.Return(func, 3_i);
    });

    auto* src = R"(
%foo = func():i32 -> %b1 {
  %b1 = block {
    if true [t: %b2] {  # if_1
      %b2 = block {  # true
        if true [t: %b3] {  # if_2
          %b3 = block {  # true
            ret 1i
          }
        }
        ret 2i
      }
    }
    ret 3i
  }
}
)";
    EXPECT_EQ(src, str());

    auto* expect = R"(
%foo = func():i32 -> %b1 {
  %b1 = block {
    %return_value:ptr<function, i32, read_write> = var
    %continue_execution:ptr<function, bool, read_write> = var, true
    if true [t: %b2] {  # if_1
      %b2 = block {  # true
        if true [t: %b3] {  # if_2
          %b3 = block {  # true
            store %continue_execution, false
            store %return_value, 1i
            exit_if  # if_2
          }
        }
        %4:bool = load %continue_execution
        if %4 [t: %b4] {  # if_3
          %b4 = block {  # true
            store %continue_execution, false
            store %return_value, 2i
            exit_if  # if_3
          }
        }
        exit_if  # if_1
      }
    }
    %5:bool = load %continue_execution
    if %5 [t: %b5] {  # if_4
      %b5 = block {  # true
        store %return_value, 3i
        exit_if  # if_4
      }
    }
    %6:i32 = load %return_value
    ret %6
  }
}
)";

    Run<MergeReturn>();

    EXPECT_EQ(expect, str());
}

}  // namespace
}  // namespace tint::ir::transform