attributes {tf._input_shapes = [#tf_type.shape<1x3>, #tf_type.shape<*>], tf.signature.is_stateful} {
  // CHECK-DAG: [[handle1:%.*]] = "tf.VarHandleOp"() <{{{.*}}, shared_name = "variable1"}>
  // CHECK-DAG: [[handle2:%.*]] = "tf.VarHandleOp"() <{{{.*}}, shared_name = "variable2"}>
  // CHECK: "tf.ReadVariableOp"([[handle1]])
  // CHECK: "tf.ReadVariableOp"([[handle2]])

  // Variable is movable, but not copyable.
  Variable(Variable&& other) = default;
  Variable& operator=(Variable&& other) = default;

  ~Variable() override;

 private:
  Variable(ImmediateExecutionContext* ctx, DataType dtype, TensorShape shape,
           absl::optional<std::string> name, ImmediateTensorHandlePtr handle);
  Variable(const Variable& variable) = delete;
  Variable& operator=(const Variable&) = delete;

namespace tensorflow {

Variable::Variable(ImmediateExecutionContext* ctx, DataType dtype,
                   TensorShape shape, absl::optional<std::string> name,
                   ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)),
      name_(name.has_value() ? *name : "Variable"),
      dtype_(dtype),
      shape_(shape),
      ctx_(ctx) {}

Variable::~Variable() {

package env

import "os"

// Variable is a wrapper for an environment variable.
type Variable string

// Name of the environment variable.
func (e Variable) Name() string {
	return string(e)
}

// Value of the environment variable.
func (e Variable) Value() string {
	return os.Getenv(e.Name())
}

def tfvariable(_):
  x = variables.Variable([1000.0], name='x', shape=[1])
  old_x = x.value()
  with ops.control_dependencies([old_x]):
    new_x = x.assign_add([42.0])
  array_ops_stack.stack([old_x, new_x], name='result')


def tfvariable_sequential_updates(_):
  x = variables.Variable(1.0, name='x')
  y = variables.Variable(1.0, name='y')
  updates = control_flow_ops.no_op()

// VariableApplyConfiguration represents an declarative configuration of the Variable type for use
// with apply.
type VariableApplyConfiguration struct {
	Name       *string `json:"name,omitempty"`
	Expression *string `json:"expression,omitempty"`
}

// VariableApplyConfiguration constructs an declarative configuration of the Variable type for use with
// apply.
func Variable() *VariableApplyConfiguration {
	return &VariableApplyConfiguration{}
}

// VariableApplyConfiguration represents an declarative configuration of the Variable type for use
// with apply.
type VariableApplyConfiguration struct {
	Name       *string `json:"name,omitempty"`
	Expression *string `json:"expression,omitempty"`
}

// VariableApplyConfiguration constructs an declarative configuration of the Variable type for use with
// apply.
func Variable() *VariableApplyConfiguration {
	return &VariableApplyConfiguration{}
}

  // CHECK: "tfl.pseudo_const"() <{value = dense<0> : tensor<3x2xi32>}> {tfl.is_variable} : () -> tensor<3x2xi32>
  %0 = "tfl.pseudo_const"() {value = dense<0> : tensor<3x2xi32>, tfl.is_variable} : () -> tensor<3x2xi32> loc("variable")
  func.return %0 : tensor<3x2xi32>

/**
 * A variable library entry.
 */
public class Variable extends AbstractLibrary {
    public Variable(Node node, FileReferenceFactory fileReferenceFactory) {
        super(node, fileReferenceFactory);
        setSourcePath(fileReferenceFactory.fromVariablePath((String) node.attribute("sourcepath")));
    }

    public Variable(FileReference library) {
        super(library);
    }

    "BUILD_ID",
    // Used by some tests to be ignored in specific build
    "BUILD_TYPE_ID",
    "JPROFILER_HOME",

    "LANG",
    "LANGUAGE",
    // It is possible to have many LC_xxx variables for different aspects of the locale. However, LC_ALL overrides all of them, and it is what CI uses.
    "LC_ALL",
    "LC_CTYPE",

    "JDK_10",
    "JDK_10_0",
    "JDK_10_0_x64",
    "JDK_10_x64",
    "JDK_11",