type: DT_FLOAT
    }
  }
  attr {
    key: "shape"
    value {
      shape {
        dim {
          size: 10
        }
      }
    }
  }
}
node {
  name: "MlirPassthroughOp"
  op: "MlirPassthroughOp"
  input: "x"
  input: "y"
  attr {
    key: "Tinputs"
    value {
      list {
        type: DT_FLOAT
        type: DT_FLOAT
      }
    }
  }
  attr {
    key: "Toutputs"

// RUN: tf-opt -allow-unregistered-dialect -tf-materialize-passthrough-op %s  | FileCheck %s


// Check that the MlirPassthroughOp is eliminated and replaced by its attached
// MLIR module.

// CHECK-LABEL: func @main
func.func @main(%arg0 : tensor<10xf32>, %arg1 : tensor<10xf32>) -> tensor<10x10xf32> {
// CHECK-SAME: (%[[ARG0:.*]]: tensor<10xf32>, %[[ARG1:.*]]: tensor<10xf32>)

==============================================================================*/

#include "tensorflow/core/framework/common_shape_fns.h"
#include "tensorflow/core/framework/op.h"

namespace tensorflow {

REGISTER_OP("MlirPassthroughOp")
    .Attr("mlir_module: string")
    .Attr("Tinputs : list(type) >= 0")
    .Input("inputs: Tinputs")
    .Attr("Toutputs : list(type) >= 0")
    .Output("outputs: Toutputs")

// CHECK: name: "plain"
// CHECK: Placeholder
// CHECK: key: "type"
// CHECK: type: DT_INT8

func.func @main(%arg0 : tensor<16xf32>) {
  tf_executor.graph {
    %1:2 = tf_executor.island wraps "tf.MlirPassthroughOp"(%arg0) {extra_type_attr = [tensor<5xi32>, tensor<16xf32>], Tinputs = [tensor<16xf32>], Toutputs = [tensor<16xf32>], mlir_module = ""} : (tensor<16xf32>) -> tensor<16xf32>
    tf_executor.fetch
  }
  func.return
}

    : public impl::MaterializePassthroughOpBase<MaterializePassthroughOpPass> {
 public:
  void runOnOperation() override;
};

void MaterializePassthroughOpPass::runOnOperation() {
  getOperation().walk([](TF::MlirPassthroughOp op) {
    std::string module_string(op.getMlirModule());
    // Parse the module.
    auto nested_module =
        parseSourceString<ModuleOp>(module_string, op.getContext());
    if (!nested_module) {

// Transforms region bases control flow operations in the TensorFlow dialect to
// their functional counterparts.
std::unique_ptr<OperationPass<ModuleOp>>
CreateTFRegionControlFlowToFunctional();

// Materialize the MlirPassthroughOp by replacing it with the MLIR module
// attached as an attribute.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateMaterializePassthroughOpPass();

      return %2 : tensor<?xi32>
    ```
  }];
}

def MaterializePassthroughOp : Pass<"tf-materialize-passthrough-op", "mlir::func::FuncOp"> {
  let summary = "Materialize the MlirPassthroughOp by replacing it with the "
    "MLIR module attached as an attribute";
  let constructor = "TF::CreateMaterializePassthroughOpPass()";
  let description = [{

  return %0 : tensor<i32>
}
```
### `-tf-materialize-passthrough-op`

_Materialize the MlirPassthroughOp by replacing it with the MLIR module attached as an attribute_

A pass that replaces MlirPassthrough ops with the code they have in
their `mlir_module` string attribute.
### `-tf-merge-control-flow`

  }];

  let arguments = (ins);

  let results = (outs
    Res<TF_ResourceTensor, "", [TF_VariableAlloc]>:$resource
  );
}

def TF_MlirPassthroughOp : TF_Op<"MlirPassthroughOp", [Pure]> {
  let summary = [{
Wraps an arbitrary MLIR computation expressed as a module with a main() function.
  }];

  let description = [{