}

    @Test
    @TestMetadata("functionalType.kt")
    public void testFunctionalType() {
      runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/nameReference/functionalType.kt");
    }

    @Test
    @TestMetadata("functionalType_parens_1.kt")
    public void testFunctionalType_parens_1() {

    }
    std::vector<Type> return_types;
    for (auto ret_op : ret->getOperands()) {
      return_types.push_back(ret_op.getType());
    }
    auto newType =
        FunctionType::get(rewriter.getContext(), argument_types, return_types);
    if (f.getFunctionType() == newType) {
      return failure();
    }
    rewriter.modifyOpInPlace(f, [&] { f.setType(newType); });

      op.erase();
    }
  }
  if (lifted_op_and_arg_idx.empty()) return success();

  // Update the function signature as well as its uses.
  target_func.setType(FunctionType::get(target_func.getContext(),
                                        block.getArgumentTypes(),
                                        func_type.getResults()));

  IRMapping mapping;
  OpBuilder builder(module_op);

    }

    @Test
    @TestMetadata("functionalType.kt")
    public void testFunctionalType() {
      runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/nameReference/functionalType.kt");
    }

    @Test
    @TestMetadata("functionalType_parens_1.kt")
    public void testFunctionalType_parens_1() {

    }

    @Test
    @TestMetadata("functionalType.kt")
    public void testFunctionalType() {
      runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/nameReference/functionalType.kt");
    }

    @Test
    @TestMetadata("functionalType_parens_1.kt")
    public void testFunctionalType_parens_1() {

        } ?: return null

        val functionLiteral = blockExpression.parent as? KtFunctionLiteral
        return if (functionLiteral != null) {
            val functionalType = getExpectedType(functionLiteral) as? KaFunctionalType
            functionalType?.returnType
        } else {
            getExpectedType(blockExpression)
        }
    }

      llvm::StringMap<Attribute>* derived_attrs) const;

  // Uses the collected attribute values to derive all the output types.
  LogicalResult DeriveOutputTypes(Location loc, FunctionType signature,
                                  const llvm::StringMap<Attribute>& attrs,
                                  SmallVectorImpl<Type>* output_types) const;

                                    PatternRewriter& rewriter,
                                    Block* insertion_point) {
  rewriter.setInsertionPointToStart(insertion_point);

  auto ftype = FunctionType::get(rewriter.getContext(), {type}, {type});
  auto name = rewriter.getStringAttr("gelu_decomp");
  func::FuncOp new_func = rewriter.create<func::FuncOp>(
      insertion_point->front().getLoc(), name, ftype);

  builder.setInsertionPointToEnd(&module_op.getBodyRegion().front());

  auto filename_input_type = RankedTensorType::get(
      /*shape=*/{}, /*elementType=*/builder.getType<TF::StringType>());

  FunctionType func_type = builder.getFunctionType(
      /*inputs=*/{filename_input_type}, /*results=*/{});
  auto save_func = builder.create<func::FuncOp>(
      NameLoc::get(builder.getStringAttr(kTfQuantSaveFuncName)),

    new_float_func_args[weight_operand_idx] = reshape_op;
    new_float_func.getArgument(weight_operand_idx).setType(new_shape);
    new_float_func.setType(FunctionType::get(
        getContext(), TypeRange{ValueRange{new_float_func_args}},
        new_float_func.getResultTypes()));
    symbol_table.insert(new_float_func);