if (!init_func) continue;

    auto init_type =
        init_func->getAttrOfType<StringAttr>(kTfSavedModelInitializerTypeAttr);
    if (!init_type) continue;

    if (init_types.contains(init_type)) {
      return init_func->emitError()
             << "Attribute tf_saved_model.initializer_type should not have "
                "duplicate values. Found duplicate: "
             << init_type;
    }

    // Do not create any new function for the operations on the localhost.
    if (IsOnLocalHost(host)) continue;

    llvm::SmallVector<mlir::Type, 4> input_types;
    llvm::SmallVector<mlir::Type, 4> result_types;
    for (Value input : metadata.inputs) {
      input_types.push_back(input.getType());
    }
    for (Value result : metadata.results) {
      result_types.push_back(result.getType());
    }

  // within the subgraph and are referenced outside the subgraph.
  llvm::SmallVector<Type> input_types =
      TypesFromValues(subgraph.FuncArguments());
  llvm::SmallVector<Type> return_types =
      TypesFromValues(subgraph.FuncOutputs());

  FunctionType function_type =
      builder.getFunctionType(input_types, return_types);

  std::string function_name = absl::StrCat("func_", subgraph.subgraph_id_);

        then:
        called
    }

    def "rule action has no inputs"() {
        when:
        def action = ruleAction({ String val -> } as Action<String>)

        then:
        action.inputTypes.empty
    }

    def "equality"() {
        def baseAction = {String val -> } as Action<String>
        def noInputsAction = ruleAction(baseAction)

        expect:

    auto* context = shape_refiner_->GetContext(&node);
    DataType dtype = node.input_type(idx);
    return ConvertDataTypeAndShape(dtype, context->input(idx),
                                   context->input_handle_shapes_and_types(idx),
                                   context, builder);
  }
  DataType dtype = node.properties()->input_types[idx];
  mlir::Type element_type;

  mlir::MLIRContext* context = tfr_module_.getContext();
  llvm::SmallVector<mlir::Type, 4> input_tys, output_tys;
  mlir::Builder builder(context);
  for (auto ty : input_dtys) {
    mlir::Type elt_ty;
    TF_RETURN_IF_ERROR(ConvertDataType(ty, builder, &elt_ty));
    mlir::TensorType mlir_ty = mlir::UnrankedTensorType::get(elt_ty);
    input_tys.push_back(mlir_ty);
  }
  for (auto ty : output_dtys) {
    mlir::Type elt_ty;

    private List collector = []

    def "creates rule action for rule source"() {
        when:
        action = RuleSourceBackedRuleAction.create(ModelType.of(List), ruleSource)

        then:
        action.inputTypes == [String, Integer, Set]

        when:
        action.execute(collector, ["foo", 1, ["bar", "baz"] as Set])

        then:
        collector == ["foo", 1, "bar", "baz"]

        where:

// attaching a to the initializer function's type so that it is identifiable.
Location CreateInitOpLoc(MLIRContext* ctx, func::FuncOp init_func_ops) {
  const std::string init_type = GetInitializerType(init_func_ops);
  const std::string name =
      absl::StrCat(init_type, "_", init_func_ops.getName().str());
  return NameLoc::get(StringAttr::get(ctx, name));
}

void MergeInitializerFunctionOpsToMainPass::runOnOperation() {

      enable_shape_inference, unconditionally_use_set_output_shapes,
      enable_soft_placement,  set_original_tf_func_name};

  auto module_or = tensorflow::GraphdefToMlirTranslateFunction(
      input, input_arrays, input_dtypes, input_shapes, output_arrays,
      control_output_arrays, options, context);
  if (!module_or.status().ok()) return nullptr;
  return std::move(module_or).value();
}

// matches `initializer_type`.
bool IsInitializerType(func::FuncOp init_func_op, StringRef initializer_type) {
  auto init_type =
      init_func_op->getAttrOfType<StringAttr>(kTfSavedModelInitializerTypeAttr);
  return init_type && init_type == initializer_type;
}

// Returns the initializer function whose tf_saved_model.initializer_type