src/tint/transform/merge_return_test.cc

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

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

#include <utility>

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

namespace tint::transform {
namespace {

using MergeReturnTest = TransformTest;

TEST_F(MergeReturnTest, ShouldRunEmptyModule) {
    auto* src = R"()";

    EXPECT_FALSE(ShouldRun<MergeReturn>(src));
}

TEST_F(MergeReturnTest, ShouldRunOnlyEntryPoints) {
    auto* src = R"(
@fragment
fn foo() {}

@compute @workgroup_size(1)
fn bar() {}
)";

    EXPECT_FALSE(ShouldRun<MergeReturn>(src));
}

TEST_F(MergeReturnTest, ShouldRunUserFuncNoReturn) {
    auto* src = R"(
fn foo() {}

@compute @workgroup_size(1)
fn bar() {
  foo();
}
)";

    EXPECT_FALSE(ShouldRun<MergeReturn>(src));
}

TEST_F(MergeReturnTest, ShouldRunUserFuncSingleReturn) {
    auto* src = R"(
fn foo() -> i32 {
  return 42;
}

@compute @workgroup_size(1)
fn bar() {
  foo();
}
)";

    EXPECT_FALSE(ShouldRun<MergeReturn>(src));
}

TEST_F(MergeReturnTest, ShouldRunUserFuncMultipleReturn) {
    auto* src = R"(
fn foo(x : i32) -> i32 {
  if (x == 0) {
    return 42;
  }
  return 0;
}

@compute @workgroup_size(1)
fn bar() {
  foo(7);
}
)";

    EXPECT_TRUE(ShouldRun<MergeReturn>(src));
}

TEST_F(MergeReturnTest, EmptyModule) {
    auto* src = R"()";

    auto* expect = src;

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, SingleExitPoint) {
    auto* src = R"(
fn foo(x : i32) -> i32 {
  var retval = 0;
  if ((x == 0)) {
    retval = 42;
  } else {
    retval = 7;
  }
  return retval;
}
)";

    auto* expect = src;

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, Basic) {
    auto* src = R"(
var<private> non_uniform_global : i32;

fn foo() {
  if (non_uniform_global == 0) {
    return;
  } else {
    return;
  }
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

fn foo() {
  var tint_return_flag : bool;
  if ((non_uniform_global == 0)) {
    {
      tint_return_flag = true;
    }
  } else {
    {
      tint_return_flag = true;
    }
  }
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, BasicRetval) {
    auto* src = R"(
var<private> non_uniform_global : i32;

fn foo() -> i32 {
  if (non_uniform_global == 0) {
    return 1;
  } else {
    return 2;
  }
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  if ((non_uniform_global == 0)) {
    {
      tint_return_flag = true;
      tint_return_value = 1;
    }
  } else {
    {
      tint_return_flag = true;
      tint_return_value = 2;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, CodeAfterIf) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  if (non_uniform_global == 0) {
    return 1;
  }
  bar = 42;
  return 2;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  if ((non_uniform_global == 0)) {
    {
      tint_return_flag = true;
      tint_return_value = 1;
    }
  }
  if (!(tint_return_flag)) {
    bar = 42;
    {
      tint_return_flag = true;
      tint_return_value = 2;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, SequenceOfConditionalReturns) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  if (non_uniform_global == 0) {
    return 1;
  }
  bar = 42;
  if (non_uniform_global == 1) {
    return 2;
  }
  bar = 43;
  if (non_uniform_global == 2) {
    return 3;
  }
  bar = 44;
  if (non_uniform_global == 3) {
    return 4;
  }
  bar = 45;
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  if ((non_uniform_global == 0)) {
    {
      tint_return_flag = true;
      tint_return_value = 1;
    }
  }
  if (!(tint_return_flag)) {
    bar = 42;
    if ((non_uniform_global == 1)) {
      {
        tint_return_flag = true;
        tint_return_value = 2;
      }
    }
    if (!(tint_return_flag)) {
      bar = 43;
      if ((non_uniform_global == 2)) {
        {
          tint_return_flag = true;
          tint_return_value = 3;
        }
      }
      if (!(tint_return_flag)) {
        bar = 44;
        if ((non_uniform_global == 3)) {
          {
            tint_return_flag = true;
            tint_return_value = 4;
          }
        }
        if (!(tint_return_flag)) {
          bar = 45;
          {
            tint_return_flag = true;
            tint_return_value = 0;
          }
        }
      }
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, NestedConditionals) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  if (non_uniform_global == 0) {
    if (true) {
      return 1;
    } else {
      return 2;
    }
  } else {
    if (true) {
      bar = 42;
    } else if (false) {
      return 3;
    } else if (true) {
      return 4;
    }
    return 5;
  }
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  if ((non_uniform_global == 0)) {
    if (true) {
      {
        tint_return_flag = true;
        tint_return_value = 1;
      }
    } else {
      {
        tint_return_flag = true;
        tint_return_value = 2;
      }
    }
  } else {
    if (true) {
      bar = 42;
    } else if (false) {
      {
        tint_return_flag = true;
        tint_return_value = 3;
      }
    } else if (true) {
      {
        tint_return_flag = true;
        tint_return_value = 4;
      }
    }
    if (!(tint_return_flag)) {
      {
        tint_return_flag = true;
        tint_return_value = 5;
      }
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, Loop) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var i = 0;
  loop {
    bar = i;
    if (non_uniform_global == 0) {
      return non_uniform_global;
    }
    if (i >= 10) {
      break;
    }
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  var i = 0;
  loop {
    bar = i;
    if ((non_uniform_global == 0)) {
      {
        tint_return_flag = true;
        tint_return_value = non_uniform_global;
        break;
      }
    }
    if ((i >= 10)) {
      break;
    }
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, NestedLoop) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var i = 0;
  loop {
    loop {
        bar = i;
        if (non_uniform_global == 0) {
          return non_uniform_global;
        }
        if (i >= 10) {
          break;
        }
    }
    bar = 10;
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  var i = 0;
  loop {
    loop {
      bar = i;
      if ((non_uniform_global == 0)) {
        {
          tint_return_flag = true;
          tint_return_value = non_uniform_global;
          break;
        }
      }
      if ((i >= 10)) {
        break;
      }
    }
    if (tint_return_flag) {
      break;
    }
    bar = 10;
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, NestedLoopAlwaysReturns) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var i = 0;
  loop {
    bar = i;
    loop {
      return non_uniform_global;
    }
    if (i == 10) {
      break;
    }
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  var i = 0;
  loop {
    bar = i;
    loop {
      {
        tint_return_flag = true;
        tint_return_value = non_uniform_global;
        break;
      }
    }
    break;
    if ((i == 10)) {
      break;
    }
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, ForLoop) {
    auto* src = R"(
var<private> non_uniform_global : array<i32, 10>;

fn foo() -> i32 {
  for (var i = 0; i < 10; i++) {
    if (non_uniform_global[i] == 0) {
      return i;
    }
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : array<i32, 10>;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  for(var i = 0; (i < 10); i++) {
    if ((non_uniform_global[i] == 0)) {
      {
        tint_return_flag = true;
        tint_return_value = i;
        break;
      }
    }
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, WhileLoop) {
    auto* src = R"(
var<private> non_uniform_global : array<i32, 10>;

fn foo() -> i32 {
  var i = 0;
  while (i < 10) {
    if (non_uniform_global[i] == 0) {
      return i;
    }
    i++;
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : array<i32, 10>;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  var i = 0;
  while((i < 10)) {
    if ((non_uniform_global[i] == 0)) {
      {
        tint_return_flag = true;
        tint_return_value = i;
        break;
      }
    }
    i++;
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, Switch) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  switch (non_uniform_global) {
    case 0 {
      return 0;
    }
    case 1 {
      if (false) {
        return 1;
      }
      bar = 6;
    }
    case 2 {
      bar = 5;
    }
    default {
      return 42;
    }
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  switch(non_uniform_global) {
    case 0: {
      {
        tint_return_flag = true;
        tint_return_value = 0;
        break;
      }
    }
    case 1: {
      if (false) {
        {
          tint_return_flag = true;
          tint_return_value = 1;
          break;
        }
      }
      bar = 6;
    }
    case 2: {
      bar = 5;
    }
    default: {
      {
        tint_return_flag = true;
        tint_return_value = 42;
        break;
      }
    }
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

TEST_F(MergeReturnTest, ComplexNesting) {
    auto* src = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  for (var i = 0; i < 10; i++) {
    bar = i;

    switch (non_uniform_global) {
      case 0 {
        return 0;
      }
      case 1 {
        if (false) {
          loop {
            if (i == non_uniform_global) {
              return 1;
            }
            continuing {
              bar++;
              break if (i == 7);
            }
          }
        }
        bar = 0;
      }
      default {
        return 42;
      }
    }
  }
  return 0;
}
)";

    auto* expect = R"(
var<private> non_uniform_global : i32;

var<private> bar : i32;

fn foo() -> i32 {
  var tint_return_flag : bool;
  var tint_return_value : i32;
  for(var i = 0; (i < 10); i++) {
    bar = i;
    switch(non_uniform_global) {
      case 0: {
        {
          tint_return_flag = true;
          tint_return_value = 0;
          break;
        }
      }
      case 1: {
        if (false) {
          loop {
            if ((i == non_uniform_global)) {
              {
                tint_return_flag = true;
                tint_return_value = 1;
                break;
              }
            }

            continuing {
              bar++;
              break if (i == 7);
            }
          }
          if (tint_return_flag) {
            break;
          }
        }
        bar = 0;
      }
      default: {
        {
          tint_return_flag = true;
          tint_return_value = 42;
          break;
        }
      }
    }
    if (tint_return_flag) {
      break;
    }
  }
  if (!(tint_return_flag)) {
    {
      tint_return_flag = true;
      tint_return_value = 0;
    }
  }
  return tint_return_value;
}
)";

    auto got = Run<MergeReturn>(src);

    EXPECT_EQ(expect, str(got));
}

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