scope.UpdateStatus(scope.DoShapeInference(ret));
  if (!scope.ok()) return Output();

  return Output(ret);
}
}  // namespace

Output Const(const Scope& scope, const Input::Initializer& val) {
  if (!val.status.ok()) {
    scope.UpdateStatus(val.status);
    return Output();
  }
  return ConstHelper(scope, val.tensor, val.tensor.dtype());
}

	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
}

// Filter filters values from a slice using a filter function.
func Filter[T any](s []T, f func(T) bool) []T {
	var r []T

namespace {
#define GEN_PASS_DEF_INSERTCALLONCEOPFROMSESSIONINITIALIZERPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

// This pass inserts a TFL::CallOnce op when tf_saved_model's session
// initializer is given.
class InsertCallOnceOpFromSessionInitializerPass
    : public impl::InsertCallOnceOpFromSessionInitializerPassBase<
          InsertCallOnceOpFromSessionInitializerPass> {
 public:

type Plugin struct {
	*generic.Plugin[PolicyHook]
}

var _ admission.Interface = &Plugin{}
var _ admission.ValidationInterface = &Plugin{}
var _ initializer.WantsFeatures = &Plugin{}
var _ initializer.WantsExcludedAdmissionResources = &Plugin{}

func NewPlugin(_ io.Reader) *Plugin {
	handler := admission.NewHandler(admission.Connect, admission.Create, admission.Delete, admission.Update)

// RUN: tf-opt %s --tf-saved-model-convert-session-initializer-to-function --split-input-file | FileCheck %s

// CHECK-LABEL: simple_initializer
// CHECK-NOT: tf_saved_model.session_initializer
// CHECK: func @session_initializer
// CHECK: call @init1
module @simple_initializer attributes {tf_saved_model.semantics} {
"tf_saved_model.session_initializer"() {initializers = [@init1]} : () -> ()
func.func @init1() attributes {tf_saved_model.exported_names = ["init1"]} {

def Test():

  x = tf.compat.v1.get_variable(
      name='x',
      shape=(5, 3),
      initializer=tf.random_normal_initializer(),
      trainable=True)
  y = tf.compat.v1.get_variable(
      name='y',
      shape=(3, 5),
      initializer=tf.random_normal_initializer(),
      trainable=True)
  z = tf.matmul(x, y)
  tensor_info_z = tf.compat.v1.saved_model.utils.build_tensor_info(z)

// license that can be found in the LICENSE file.

// Using the same name for a field in a composite literal and for a
// global variable that depends on the variable being initialized
// caused gccgo to erroneously report "variable initializer refers to
// itself".

package p

type S struct {
	F int
}

var V = S{F: 1}

    }

    private static class BuildScopeCompileServices implements ServiceRegistrationProvider {
        void configure(ServiceRegistration registration, JdkToolsInitializer initializer) {
            // Hackery
            initializer.initializeJdkTools();
        }

        @Provides

    if (compileTimeInitializer != null) {
        return KaConstantInitializerValue(compileTimeInitializer.toKtConstantValue(), initializer)
    }
    if (initializer != null) {
        val bindingContext = analysisContext.analyze(initializer)
        val constantValue = ConstantExpressionEvaluator.getConstant(initializer, bindingContext)
        if (constantValue != null) {

        file("src/test/java/FooTest.java") << """
            import org.testng.annotations.*;
            import java.io.PrintStream;

            public class FooTest {
                static PrintStream out = System.out;
                static PrintStream err = System.err;
                static { out.println("cool output from initializer"); }