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

# shellcheck disable=SC2016
yq ea '. as $item ireduce ({}; . *d $item )' ./common/config/.golangci.yml ./tools/golangci-override.yaml > ./common/config/.golangci.yml.tmp

// RUN: tf-reduce %s -reduction-tree='traversal-mode=0 test=%S/reducer/unsupported-op-test.sh' | FileCheck %s

// CHECK: @target_function
func.func @target_function() -> tensor<i32> {
  %0 = "tf_device.cluster"() ({
    // CHECK: tf.UnsupportedOp
    %1 = "tf.UnsupportedOp"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
    // CHECK: tf.Identity
    %2 = "tf.Identity"(%1) : (tensor<i32>) -> tensor<i32>
    // CHECK-NOT: tf.Identity

LogicalResult MatchReduceToArgMinMaxType2(mhlo::ReduceOp reduce_op,
                                          bool is_argmax);

// Base class for converting mhlo::ReduceOp to TF/TFL ArgMax/ArgMin ops.
template <typename Reduce, typename ArgReduce, typename BooleanReduce,
          bool is_argmax>
class ConvertReduceOpToArgMinMax : public OpConversionPattern<mhlo::ReduceOp> {
 public:
  using OpConversionPattern::OpConversionPattern;

limitations under the License.
==============================================================================*/

#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/legalize_hlo_conversions/reduce.h"

#include <optional>

#include "llvm/Support/Casting.h"
#include "mlir/IR/Block.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project

var limited1 = Map[int, byte](input, limiter)
var limited2 = Map(input, limiter) // using type inference

func reducer(x float64, y int) float64 {
	return x + float64(y)
}

var reduced1 = Reduce[int, float64](input, 0, reducer)
var reduced2 = Reduce(input, 1i, reducer) // using type inference
var reduced3 = Reduce(input, 1, reducer) // using type inference

func filter(x int) bool {
	return x&1 != 0
}

var limited2 = Map(input, limiter) // using type inference

func reducer(x float64, y int) float64 {
	return x + float64(y)
}

var reduced1 = Reduce[int, float64](input, 0, reducer)
var reduced2 = Reduce(input, 1i /* ERROR "overflows" */, reducer) // using type inference
var reduced3 = Reduce(input, 1, reducer) // using type inference

func filter(x int) bool {
	return x&1 != 0
}

// RUN: tf-opt %s -split-input-file -tfl-reduce-type-precision -verify-diagnostics

func.func @testI8ToI4WithinRange() -> (tensor<4xi8>) {
  %0 = arith.constant dense<[-8, 0, 1, 7]> : tensor<4xi8>
  // expected-error@+1 {{type of return operand 0 ('tensor<4xi4>') doesn't match function result type ('tensor<4xi8>')}}
  func.return %0 : tensor<4xi8>
}

func.func @testI8ToI4NotWithinRange() -> tensor<4xi8> {
  %0 = arith.constant dense<[-10, 2, 3, 8]> : tensor<4xi8>

                externalNodes.addAll(reduce(ref, it))
            } ?: externalNodes.add(ref)
        }
        reducing.remove(node)

        return externalNodes
    }

    for ((node, refs) in graph) {
        reduce(node, refs)
    }

    return result

        "tf-reduce-identity.mlir": ["no_windows"],
    },
    test_file_exts = ["mlir"],
)

# Bundle together all of the test utilities that are used by tests.
filegroup(
    name = "test_utilities",
    testonly = True,
    data = [
        ":reducer_tester",
        "//tensorflow/compiler/mlir:tf-opt",
        "//tensorflow/compiler/mlir:tf-reduce",
        "@llvm-project//llvm:FileCheck",

func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
	r := make([]T2, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r
}

// Reduce reduces a []T1 to a single value using a reduction function.
func Reduce[T1, T2 any](s []T1, initializer T2, f func(T2, T1) T2) T2 {
	r := initializer
	for _, v := range s {
		r = f(r, v)
	}
	return r
}