}

TEST_F(ConvertMlirModuleToExportedModelTest, FunctionAliasesSet) {
  // Define a module with 2 function calls, function_1 and function_2.
  mlir::OwningOpRef<mlir::ModuleOp> module_op = ParseModuleOpString(R"mlir(
    module attributes {tf_saved_model.semantics} {
      func.func private @function_1() -> () attributes {tf._original_func_name = "__func_1"} {
        tf_executor.graph {

        key(0) cost(100) device("/CPU:0") "some.op"(%arg)
        {fn = function_1} {attr1 = value, attr2 = value2} : 1

    Note that in this case, the first braket contains op attributes other than
    function attributes, and the second braket contains function attributes,
    which represent function names.

    Refer to b/172597167 for approaches considered for supporting function
    attributes.
  }];

  let arguments = (ins

// CHECK-NEXT:       input_arg {
// CHECK-NEXT:         name: "function0"
// CHECK:            input_arg {
// CHECK-NEXT:         name: "function01"
// CHECK:            output_arg {
// CHECK-NEXT:         name: "function02"
// CHECK:          node_def {
// CHECK-NEXT:       name: "[[NAME:[^"]*]]"
// CHECK-NEXT:       op: "Identity"
// CHECK-NEXT:       input: "function0"
// CHECK:          ret {

    /**
     * Returns the functional type of the given [KtFunction].
     *
     * For a regular function, it would be kotlin.FunctionN<Ps, R> where
     *   N is the number of value parameters in the function;
     *   Ps are types of value parameters;
     *   R is the return type of the function.
     * Depending on the function's attributes, such as `suspend` or reflective access, different functional type,

#include "tensorflow/core/platform/statusor.h"

namespace tf {
namespace libtf {

class Function {
 public:
  tensorflow::Status RegisterTrace(tensorflow::AbstractFunctionPtr,
                                   TaggedValue input_signature,
                                   TaggedValue output_signature);

  // Executes this function under the execution context.
  //
  // Raises an error is no matching signature is found for TaggedValue.

// Check that the `tf._resource_arg_unique_id` argument attributes of
// test_func_name0 are propagated to the function's arg_attr and
// resource_arg_unique_id.

// CHECK:      name: "x"
// CHECK:      op: "VarHandleOp"

// CHECK:      name: "func_call"
// CHECK:      input: "called"

// CHECK:      library
// CHECK:        function
// CHECK:          signature
// CHECK:            input_arg
// CHECK:              type: DT_RESOURCE

 * limitations under the License.
 */

package org.gradle.internal.classpath.declarations;

import kotlin.io.FilesKt;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.functions.Function2;
import org.gradle.internal.Cast;
import org.gradle.internal.classpath.Instrumented;
import org.gradle.internal.instrumentation.api.annotations.CallableKind.StaticMethod;

mutable.Builder newBuilder(); public abstract void foreach(scala.Function1); public abstract boolean isEmpty(); public abstract Object map(scala.Function1, generic.CanBuildFrom); public abstract Object flatMap(scala.Function1, generic.CanBuildFrom); public abstract Object filter(scala.Function1); public abstract Object filterNot(scala.Function1); public abstract scala.Tuple2 partition(scala.Function1); public abstract boolean forall(scala.Function1); public abstract boolean exists(scala.Function1); public...

public final class MainKt {
    // source: 'main.kt'
    public final static method PostCardSimple(p0: kotlin.jvm.functions.Function1, p1: boolean, p2: kotlin.jvm.functions.Function0): void

// RUN: tf-opt -tf-executor-to-functional-conversion %s -split-input-file -verify-diagnostics | FileCheck %s

func.func @unsupported_op() {
  tf_executor.graph {
    // expected-error@+1 {{'tf_executor.ControlTrigger' op is not supported for lifting out of tf_executor.graph, expected tf_executor.island}}
    %control = tf_executor.ControlTrigger {}
    tf_executor.fetch
  }
  func.return
}

// -----

// CHECK-LABEL: func @empty_graph