ctx.device(), inputs,
                                                variable_indices, variables));
  TF_RETURN_IF_ERROR(LockVariables(absl::MakeSpan(*variables)));
  TF_ASSIGN_OR_RETURN(*args,
                      XlaComputationLaunchContext::BuildXlaCompilerArguments(
                          constant_indices, inputs, *variables,
                          static_cast<Device*>(ctx.device())));

                             const Scope& scope, Output* output) {
  TF_RETURN_IF_ERROR(scope.status());
  const auto unique_name = scope.GetUniqueNameForOp(op_name);
  auto builder = ::tensorflow::NodeBuilder(unique_name, op_name);
  for (const auto& input : inputs) {
    TF_RETURN_IF_ERROR(scope.status());
    builder = builder.Input(input.node());
  }
  ::tensorflow::Node* ret;

  opcode_index:uint;

  // Optional input are indicated by -1.
  inputs:[int];
  outputs:[int];

  builtin_options:BuiltinOptions;
  custom_options:[ubyte];
  custom_options_format:CustomOptionsFormat;

  // A list of booleans indicating the input tensors which are being mutated by
  // this operator.(e.g. used by RNN and LSTM).
  // For example, if the "inputs" array refers to 5 tensors and the second and

 * As these phases gradually become more interleaved, we might generalize these states so that the value is "changing" only until its inputs are known and all such inputs have a "fixed" value.
 * A provider whose inputs are only configuration time inputs would become fixed once the configuration of those inputs has completed. A provider whose inputs include a task output would become

    }

    def "out-of-date when any input property removed"() {
        given:
        execute(builder.withProperty("prop2", "value").build())

        expect:
        outOfDate(unitOfWork, "Input property 'prop2' has been removed for ${unitOfWork.displayName}")
    }

    def "up to date when no inputs"() {
        when:

          th->CopyToDevice(*context, /*d=*/nullptr, &inputs_storage.back()));
      inputs[i + offset] = &inputs_storage.back();
    } else {
      inputs[i + offset] = t;
    }
  }

  if (dev != nullptr) {
    TF_RETURN_IF_ERROR(GetVariableInfosFromInputs(dev->resource_manager(), dev,
                                                  inputs, resource_arg_indices,
                                                  &variable_infos));

                'typeName' : 'MyTask',
                'propertyName' : 'setPropertyInput',
            ]
        }
    }

    def "detects problems with file inputs"() {
        file("input.txt").text = "input"
        file("input").createDir()

        javaTaskSource << """
            import org.gradle.api.*;
            import org.gradle.api.file.*;
            import org.gradle.api.tasks.*;

  // CHECK-DAG: %[[INPUT:.*]] = mhlo.bitcast_convert %arg0 : (tensor<3x2xi32>) -> tensor<3x2x!quant.uniform<i32:f32:1, {2.000000e+00:4,2.000000e+00:4}>>
  // CHECK-DAG: %[[MAX:.*]] = mhlo.bitcast_convert %arg1 : (tensor<3x2xi32>) -> tensor<3x2x!quant.uniform<i32:f32:1, {2.000000e+00:4,2.000000e+00:4}>>
  // CHECK-DAG: %[[INPUT_1:.*]] = chlo.broadcast_maximum

/**
 * A future whose value is derived from a collection of input futures.
 *
 * @param <InputT> the type of the individual inputs
 * @param <OutputT> the type of the output (i.e. this) future
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
abstract class AggregateFuture<InputT extends @Nullable Object, OutputT extends @Nullable Object>
    extends AggregateFutureState<OutputT> {

                                PatternRewriter& rewriter) const override {
    auto input = op.getOptional();
    auto elementType = getElementTypeOrSelf(input.getType());
    if (isa<TF::VariantType>(elementType)) {
      // We can only replace OptionalGetValue after the inputs have been
      // replaced.
      return failure();
    }