Location loc = host_compute.getLoc();
  bool manual_sharding = host_compute.getManualSharding();

  SmallVector<Value, 4> send_tokens;
  for (auto operand : llvm::enumerate(host_compute.getInputs())) {
    auto send_token = CreateSendOp(
        builder, loc, operand.value(), host_compute.getSendKey(),
        operand.index(), token, xla::kXlaHostTransferTfRendezvousHandlerName,
        manual_sharding);

    if (op.getN() == 1) {
      rewriter.replaceOpWithNewOp<UnaryEinsumOp>(
          op, op.getType(), *op.getInputs().begin(), equation);
    } else if (op.getN() == 2) {
      ValueRange inputs = op.getInputs();
      rewriter.replaceOpWithNewOp<EinsumOp>(op, op.getType(), inputs[0],
                                            inputs[1], equation);
    } else {

        BindingPredicate mappedSubject = mapSubject(subject, role);
        List<BindingPredicate> mappedInputs = mapInputs(mutator.getInputs());
        RuleBinder binder = new RuleBinder(mappedSubject, mappedInputs, mutator, unboundRules);
        ruleBindings.add(binder);
        return binder;
    }

    @Override

            status = pi.emitOpError()
                     << "requires " << num_cores_per_replica
                     << " operands but found " << pi->getNumOperands();
          for (auto operand : pi.getInputs()) {
            if (auto ri =
                    llvm::dyn_cast_or_null<mlir::TF::TPUReplicatedInputOp>(
                        operand.getDefiningOp())) {
              if (!seen_ops.contains(ri)) {

     */
    void setGroup(@Nullable String group);

    /**
     * <p>Returns the inputs of this task.</p>
     *
     * @return The inputs. Never returns null.
     */
    @Internal
    TaskInputs getInputs();

    /**
     * <p>Returns the outputs of this task.</p>
     *
     * @return The outputs. Never returns null.
     */
    @Internal
    TaskOutputs getOutputs();

    /**

void AddCallOpInWhileOpRegion(mlir::Region& region, mlir::func::FuncOp func) {
  OpBuilder op_builder{region};
  region.push_back(new mlir::Block());
  Location loc = region.getLoc();
  auto inputs = func.getFunctionType().getInputs();
  region.addArguments(inputs, mlir::SmallVector<Location>(inputs.size(), loc));
  op_builder.setInsertionPointToStart(&region.front());
  auto call_op = op_builder.create<mlir::func::CallOp>(

  auto new_return =
      builder.create<func::ReturnOp>(old_return->getLoc(), old_and_new_retvals);
  old_return->erase();
  callee.setType(FunctionType::get(
      callee.getContext(), callee.getFunctionType().getInputs(),
      llvm::to_vector<4>(new_return.getOperandTypes())));
  return success();
}

// Updates a PartitionedCallOp/StatefulPartitionedCallOp according to the

          while_op.getInput().getTypes(), while_op.getOutput().getTypes(),
          while_op.ResolveBodyFunction(&symbol_table_)
              .getFunctionType()
              .getInputs());
      return PropagateShapeToFunctions(
          module, compatible_types,
          {while_op.ResolveCondFunction(&symbol_table_),
           while_op.ResolveBodyFunction(&symbol_table_)},

  // pairs.
  TF_RETURN_IF_ERROR(AddBackedges());

  TF_RETURN_IF_ERROR(ConvertFunctionArgAndRets(function, graph,
                                               func_type.getInputs(), arg_nodes,
                                               ret_nodes, control_ret_nodes));

  // TODO(jpienaar): Update post removing shape_refinier_.
  if (!specs_.enable_shape_inference) {

Method <org.gradle.platform.base.ApplicationBinarySpec.getApplication()> does not have raw return type assignable to org.gradle.api.provider.Provider in (ApplicationBinarySpec.java:0)
Method <org.gradle.platform.base.BinarySpec.getInputs()> does not have raw return type assignable to org.gradle.api.provider.Provider in (BinarySpec.java:0)