// Creates a pass that moves & merges initializer function's ops into the @main
// function. This pass should be run on a valid tf_executor dialect. The control
// output of the initializer function for non-variable resource initialization
// will be passed on as a dependency to a new `tf.NoOp`, whose control output
// will be merged into the main function's FetchOp. The initializer functions
// will be removed.
//

  }
  return bytecode;
}

// Serializes the stablehlo functions called by XlaCallModuleOp to bytecode
// and embeds the bytecode in XlaCallModuleOp's `module` attribute.
//
// The stablehlo functions include the function referred by XlaCallModuleOp's
// `_entry_function` attribute, and any stablehlo functions called transitively
// from the entry function.
LogicalResult SerializeXlaCallModule(SymbolTableCollection& symbol_table,

    }

    private static boolean isKotlinFunction0Deferrable(@Nullable Object value) {
        return value instanceof kotlin.jvm.functions.Function0;
    }

    @Nullable
    private static Object unpackKotlinFunction0(Object value) {
        return ((kotlin.jvm.functions.Function0) value).invoke();
    }

# RUN: tf-mlir-translate -graphdef-to-mlir -tf-enable-shape-inference-on-import=false %s -o - | FileCheck %s

# Verify that we properly import call site function attributes.
# CHECK: tf.If
# CHECK-SAME: then_branch = @
# CHECK-SAME: then_branch.how_many = 32
# CHECK-SAME: then_branch.ping = "ack"

node {
  name: "Placeholder"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {

namespace mlir {
namespace TF {

// The main function's name in the serialized stablehlo module embedded in
// XlaCallModule's `module` attribute.
constexpr llvm::StringRef kStablehloMainFunctionName = "main";

// After deserializing the stablehlo functions from XlaCallModule,
// this XlaCallModule attribute refers to the deserialized stablehlo main
// function.

  // Iterate over the sorted list of functions to keep order deterministic.
  for (func::FuncOp func : GetSortedFunctions(module_op)) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError()
          << "quant-stablehlo-lift-quantizable-spots-as-functions failed.";
      signalPassFailure();
    }
  }

  // Remove all attr_map attributes.

abstract boolean isEmpty(); public final boolean isDefined(); public abstract Object get(); public final Object getOrElse(Function0); public final Option map(Function1); public final Option flatMap(Function1); public final Option filter(Function1); public final Option$WithFilter withFilter(Function1); public final boolean forall(Function1); public final Option orElse(Function0); public final collection.immutable.List toList(); public void Option(); } scala/Option$WithFilter.class package scala; public...

	// For ABIs other than this function's definition ABI, the
	// compiler generates ABI wrapper functions. This is only tracked
	// within a package.
	ABIRefs obj.ABISet

	NumDefers  int32 // number of defer calls in the function
	NumReturns int32 // number of explicit returns in the function

	// NWBRCalls records the LSyms of functions called by this

//go:generate go run make_tables.go

// Package bits implements bit counting and manipulation
// functions for the predeclared unsigned integer types.
//
// Functions in this package may be implemented directly by
// the compiler, for better performance. For those functions
// the code in this package will not be used. Which
// functions are implemented by the compiler depends on the
// architecture and the Go release.
package bits

    @Test
    fun `#kotlinTypeStringFor Kotlin function type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<(String) -> String>()),
            equalTo("kotlin.jvm.functions.Function1<String, String>")
        )
    }

    @Test
    fun `#kotlinTypeStringFor Java function type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<java.util.function.Function<String, String>>()),