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.
//

  %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),

// 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,

    key: "_class"
    value {
      list {
        s: "loc:@Variable"
      }
    }
  }
  attr {
    key: "use_locking"
    value {
      b: true
    }
  }
  attr {
    key: "validate_shape"
    value {
      b: true
    }
  }
}
node {
  name: "Variable/read"
  op: "Identity"
  input: "Variable"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }

    "tf.AssignVariableOp"(%arg0, %3) <{validate_shape = false}> : (tensor<*x!tf_type.resource<tensor<1xf32>>>, tensor<1xf32>) -> ()
    tf_device.return
  }
  func.return
}

func.func private @write_chain_func(%arg0: tensor<1xf32>) -> (tensor<1xf32>) {

    %0 = "tf.VarHandleOp"() <{container = "", shared_name = "Variable"}> : () -> tensor<!tf_type.resource<tensor<!tf_type.string>>>
    "tf.AssignVariableOp"(%0, %cst) <{validate_shape = false}> : (tensor<!tf_type.resource<tensor<!tf_type.string>>>, tensor<!tf_type.string>) -> ()
    %2 = "tf.ReadVariableOp"(%0) : (tensor<!tf_type.resource<tensor<!tf_type.string>>>) -> tensor<*x!tf_type.string>

    key: "_class"
    value {
      list {
        s: "loc:@var"
      }
    }
  }
  attr {
    key: "use_locking"
    value {
      b: true
    }
  }
  attr {
    key: "validate_shape"
    value {
      b: true
    }
  }
}
node {
  name: "var/read"
  op: "Identity"
  input: "var"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }