}
  return absl::OkStatus();
}

Status MlirFunctionContext::Finalize(OutputList* outputs,
                                     AbstractFunction** f) {
  Block& body = func_.getBody().front();
  SmallVector<Value, 8> ret_operands;
  for (auto* output : outputs->outputs) {
    auto* operand = dyn_cast<MlirTensor>(output);
    if (!operand)
      return InvalidArgument("Capturing eager tensors is not supported yet.");

          "quantization": {
          }
        },
        {
          "shape": [2, 2],
          "name": "output",
          "quantization": {
          }
        }
      ],
      "inputs": [0],
      "outputs": [1],
      "operators": [
        {
          "inputs": [ 0 ],
          "outputs": [ 1 ],
          "builtin_options_type": "ReshapeOptions",
          "builtin_options": {

        // TODO - should just write this as a bean field of the outputs object, and also do this for the registered properties above
        if (task.outputs.upToDateSpec.isEmpty) {
            writeBoolean(false)
        } else {
            writeBoolean(true)
            write(task.outputs.upToDateSpec)
        }
    }

    private

            16
          ],
          "name": "output",
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        3
      ],
      "operators": [
        {
          "inputs": [
            0,
            1,
            -1
          ],
          "outputs": [
            3
          ],

    if (!output_tensor_type) {
      return switchn.emitOpError()
             << "expects outputs to have tensor type but got " << output_type;
    }

    // If the output type is a ref type, then the operand type should also be of
    // the same ref type. However, if the output type is a non-ref type T, then
    // the operand can be tensor of type T or T_REF.

                    @Override
                    public void transform(TransformOutputs outputs) {
                        File input = getInputArtifact().get().getAsFile();
                        File output = outputs.file(input.getName() + ".txt");

                        try {
                            Files.write(output.toPath(), Collections.singleton(String.valueOf(input.length())));

		gpcas       = regInfo{inputs: []regMask{gp | sp | sb, gp, gp}, outputs: []regMask{gp}}
		fp01        = regInfo{inputs: nil, outputs: []regMask{fp}}
		fp11        = regInfo{inputs: []regMask{fp}, outputs: []regMask{fp}}
		fpgp        = regInfo{inputs: []regMask{fp}, outputs: []regMask{gp}}
		gpfp        = regInfo{inputs: []regMask{gp}, outputs: []regMask{fp}}

  shard_output_types.reserve(outputs.size());
  full_output_types.reserve(outputs.size());
  for (const auto& output : outputs) {
    Type shard_type;
    if (failed(GetShardShapedType(original_op, num_cores_per_replica,
                                  output.getType(), shard_type)))
      return mlir::failure();
    shard_output_types.push_back(shard_type);
    full_output_types.push_back(output.getType());
  }

  for (const Value original_output_value : outputs) {
    // Use the mapped values in the newly created function that correspond to
    // outputs in the original function.
    result_values.push_back(mapper.lookup(original_output_value));
  }
  builder.create<func::ReturnOp>(module_op.getLoc(), result_values);

  // 2) Create XlaCallModuleOp (with ops mapped).
  CreateXlaCallModuleOp(inputs, outputs, result_types, reverse_subgraph,

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    ${server.callFromBuild('size-transform')}
                    File output = outputs.file(input.name + parameters.suffix)
                    output.text = String.valueOf(input.length())
                }
            }