"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);

      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}")

        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 {

  OpBuilder builder(context);
  FunctionType type;
  if (passthru_extra_args) {
    type = FunctionType::get(context, types, types);
  } else {
    SmallVector<Type, 4> result_types;
    auto operands = region.front().getTerminator()->getOperandTypes();
    result_types.append(operands.begin(), operands.end());
    type = FunctionType::get(context, types, result_types);
  }

  }

  @Test
  @TestMetadata("funtionType.kt")
  public void testFuntionType() {
    runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/funtionType.kt");
  }

  @Test
  @TestMetadata("localDeclarations.kt")
  public void testLocalDeclarations() {

  }

  @Test
  @TestMetadata("funtionType.kt")
  public void testFuntionType() {
    runTest("analysis/analysis-api/testData/components/expressionTypeProvider/declarationReturnType/funtionType.kt");
  }

  @Test
  @TestMetadata("localDeclarations.kt")
  public void testLocalDeclarations() {