TF_RETURN_IF_ERROR(op_ptr->AddInput(resource));
  TF_RETURN_IF_ERROR(op_ptr->AddInput(value));
  TF_RETURN_IF_ERROR(op_ptr->SetAttrBool("validate_shape", validate_shape));
  int num_retvals = 0;
  std::vector<AbstractTensorHandle*> dummy_outputs;
  return op_ptr->Execute(absl::MakeSpan(dummy_outputs), &num_retvals);
}

// Op: DestroyResourceOp()
// Summary: Deletes the resource specified by the handle.
//

    "tf.AssignVariableOp"(%arg3, %13#10) <{validate_shape = false}> : (tensor<*x!tf_type.resource<tensor<128x1024xf32>>>, tensor<128x1024xf32>) -> ()
    "tf.AssignVariableOp"(%arg5, %13#8) <{validate_shape = false}> : (tensor<*x!tf_type.resource<tensor<1024x1xf32>>>, tensor<1024x1xf32>) -> ()

// CHECK: "tf.AssignVariableOp"(%[[VAR_HANDLE_0]], %[[RESTORE]]#0) <{validate_shape = false}> : (tensor<!tf_type.resource<tensor<2xf32>>>, tensor<2xf32>) -> ()
// CHECK: "tf.AssignVariableOp"(%[[VAR_HANDLE_1]], %[[RESTORE]]#1) <{validate_shape = false}> : (tensor<!tf_type.resource<tensor<4xi32>>>, tensor<4xi32>) -> ()

// Test that the locs are properly set to their shared_names.

  %1 = "tf.Const"() {value = dense<0> : tensor<i32>} : () -> tensor<i32>
  %2 = "tf.Assign"(%0, %1) {T = i32, device = "", use_locking = true, validate_shape = true} : (tensor<!tf_type.int32ref>, tensor<i32>) -> tensor<!tf_type.int32ref>
  func.return
}

// CHECK-LABEL: @inference
func.func @inference() -> tensor<i32> {
  // CHECK-NOT: tf.VariableV2

  (TF_ReadVariableOp:$result $resource),
  (TFL_ReadVariableOp $resource),
  [(HasSupportedElementType $result)]>;

def LegalizeAssignVariable : Pat<
  (TF_AssignVariableOp $resource, $value, $validate_shape),
  (TFL_AssignVariableOp $resource, $value),

    %control_13 = tf_executor.island(%control_12) wraps "tf.AssignVariableOp"(%outputs_9, %outputs_11) {validate_shape = false} : (tensor<!tf_type.resource<tensor<20x4096xf32>>>, tensor<20x4096xf32>) -> ()
    %control_14 = tf_executor.island(%control_13) wraps "tf.NoOp"() : () -> ()

          name: "output_ref"
          type_attr: "T"
          is_ref: true
        }
        attr {
          name: "T"
          type: "type"
        }
        attr {
          name: "validate_shape"
          type: "bool"
          default_value {
            b: true
          }
        }
        attr {
          name: "use_locking"
          type: "bool"
          default_value {

// conditions are met:
//   1. `validate_shape` is set to `true`
//   2. The variable is initialized
//   3. The shape of the value tensor doesn't match the shape of the variable
//      tensor.
TF_CAPI_EXPORT extern void TF_AssignVariable(
    TF_OpKernelContext* ctx, int input_index, int value_index,
    bool validate_shape,
    void (*copyFunc)(TF_OpKernelContext* ctx, TF_Tensor* source,

Status AssignVariableOp(AbstractContext* ctx,
                        AbstractTensorHandle* const resource,
                        AbstractTensorHandle* const value,
                        bool validate_shape = false, const char* name = nullptr,
                        const char* raw_device_name = nullptr);

// Deletes the resource specified by the handle.
Status DestroyResourceOp(AbstractContext* ctx,

  // CHECK: "tf.AssignVariableOp"([[VAR_HANDLE]], [[NEW_VAR]]) <{validate_shape = false}> : (tensor<*x!tf_type.resource<tensor<*xf32>>>, tensor<*xf32>) -> ()
  // CHECK: "tf.AssignVariableOp"([[M_HANDLE]], [[NEW_M]]) <{validate_shape = false}> : (tensor<*x!tf_type.resource<tensor<*xf32>>>, tensor<*xf32>) -> ()
  // CHECK: "tf.AssignVariableOp"([[V_HANDLE]], [[NEW_V]]) <{validate_shape = false}> : (tensor<*x!tf_type.resource<tensor<*xf32>>>, tensor<*xf32>) -> ()