"func.func"() ({
  ^bb0(%arg0: tensor<i32>):
    "func.return"(%arg0) : (tensor<i32>) -> ()
  }) {sym_name = "main_while_body_4225150", sym_visibility = "private", tf._input_shapes = [#tf_type.shape<>], tf.signature.is_stateful, function_type = (tensor<i32>) -> (tensor<i32>)} : () -> ()
  "func.func"() ({

  // passing the platform index.
  FunctionType function_type = func_op.getFunctionType();
  ArrayRef<Type> new_input_types =
      function_type.getInputs().take_back(func_op.getNumArguments() - 1);
  func_op.setFunctionType(
      FunctionType::get(ctx, new_input_types, function_type.getResults()));
  func_op.getBody().eraseArgument(0);
}

}  // namespace

      TypesFromValues(subgraph.FuncOutputs());

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

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

  func::FuncOp new_func = func::FuncOp::create(builder.getUnknownLoc(),
                                               function_name, function_type);
  new_func.setVisibility(func::FuncOp::Visibility::Private);

        "tf_executor.yield"() : () -> ()
      }) : () -> !tf_executor.control
      "tf_executor.fetch"() : () -> ()
    }) : () -> ()
    "func.return"() : () -> ()
  }) {sym_name = "main", function_type = () -> ()} : () -> ()
}) {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 126 : i32}} : () -> ()

      tfr.tensor > tfr.tensor_list > tfr.attr/i32/...,
    and only one trfr.tensor_list argument is allowed.
  }];

  let arguments = (ins
    TypeAttrOf<FunctionType>:$function_type,
    StrAttr:$sym_name,
    OptionalAttr<DictArrayAttr>:$arg_attrs,
    OptionalAttr<DictArrayAttr>:$res_attrs
  );

  let results = (outs);

            res_types, res_attrs)))
      return failure();

    // Update the function type which has excluded the control args.
    func->setAttr("function_type", TypeAttr::get(rewriter.getFunctionType(
                                       arg_types, res_types)));

    // Update arg/result attributes.
    func.setAllArgAttrs(arg_attrs);

        val (type, functionClassKind) = executeOnPooledThreadInReadAction {
            analyseForTest(expressionAtCaret) {
                val functionType = expressionAtCaret.getExpectedType()
                functionType?.render(position = Variance.INVARIANT) to functionType?.functionTypeKind
            }
        }
        val actual = buildString {
            appendLine("expression: ${expressionAtCaret.text}")

void init_types(py::module& m) {
  // Type
  py::class_<mlir::Type> Type(m, "Type");

  // Type Sub-classes
  py::class_<mlir::FunctionType, mlir::Type>(m, "FunctionType")
      .def("getResults",
           [](mlir::FunctionType& ft) { return ft.getResults().vec(); });

  py::class_<mlir::FloatType, mlir::Type>(m, "FloatType")
      .def("getBF16", &mlir::FloatType::getBF16)

        then:
        outputContains("project name = root")
        outputContains("project name = a")
        outputContains("project name = b")
    }

    def "lifecycle actions in Groovy DSL allow using #functionType function defined in a class"() {
        createDirs("a", "b")
        settingsFile << """
            rootProject.name = "root"
            include("a", "b")

            class Helper {

class FuncOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: str, arg1: FunctionType) -> FuncOp: ...
    def getArguments(self) -> list[BlockArgument]: ...
    def getBody(self) -> Region: ...
    def getName(self) -> str: ...
    def getType(self) -> FunctionType: ...

class FunctionType(Type):
    def __init__(self, *args, **kwargs) -> None: ...
    def getResults(self) -> list[Type]: ...