module_op.walk([&results](func::CallOp call_op) {
    std::optional<QuantizationResult> result = GetQuantizationResult(call_op);
    if (result == std::nullopt) return WalkResult::skip();

    *results.add_results() = std::move(*result);
    return WalkResult::advance();
  });
}

// Populates non-quantized ops from `module_op` to `results`. After going

  TF_ASSIGN_OR_RETURN(
      std::vector<std::unique_ptr<xla::AotCompilationResult>> aot_results,
      client_->CompileAheadOfTime(*result.computation, argument_layouts,
                                  build_options));
  TF_RET_CHECK(aot_results.size() == 1);
  return aot_results[0]->SerializeAsString();
}

absl::StatusOr<std::unique_ptr<xla::LocalExecutable>>
XlaDeviceCompilerClient::LoadExecutable(

        def provider1 = setProvider("foo")

        when:
        source.addPendingCollection(provider1)
        source.realizePending()
        boolean addResult = source.add("foo")
        provider1.value = []

        then:
        addResult
        source.iterator().collect() == ["foo"]
    }

    def "adding is not ignored when an unrealized provider currently has the same value"() {

  // CHECK-DAG: %[[filter:.*]] = arith.constant dense<{{.*}}> : tensor<4x4xf32>
  // CHECK: %[[fc_result:.*]] = "tfl.fully_connected"(%arg0, %arg1, %[[unit]])
  // CHECK: %[[add_result:.*]] = tfl.add %[[fc_result]], %[[filter]]
  // CHECK: return %[[add_result]]
}

// CHECK-LABEL: @FuseFullyConnectedAddWithUnfusableRhs
func.func @FuseFullyConnectedAddWithUnfusableRhs(%arg0: tensor<4x37xf32>, %arg1: tensor<4x37xf32>) -> tensor<4x4xf32> {

    %add_result = "tf.Add"(%computation, %computation) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    // expected-error@+1 {{Input of TPUPartitionedOutputV2 must be in tpu computation.}}
    %partitioned_output:2 = "tf.TPUPartitionedOutputV2"(%add_result) {N = 2 : i64, partition_dims = []} : (tensor<i32>) -> (tensor<i32>, tensor<i32>)