class_docstr: Python AST visitor pass which finally lowers it to HalideIR
code: def visit_Assign(self, node):
      rhs = self.visit(node.value)
      if isinstance(rhs, Operation):
          rmap = {}
          _internal_assert(
              len(node.targets) == rhs.num_outputs,
              "Unable to detuple the outs to targets",
          )
          for i in range(rhs.num_outputs):
              _internal_assert(
                  isinstance(node.targets[i], ast.Name),
                  "You should bind a pure name to the tensors",
              )
              self.add_symbol(
                  node.targets[i].id, Symbol.GlobalBuffer, rhs.output(i)
              )
              rmap[rhs.outputs[i].op] = rhs.output(i)
          return utils.replace_io(rhs.body, rmap)
  
      _internal_assert(
          len(node.targets) == 1,
          "So far only one-valued assignment is supported!",
      )
      lhs = node.targets[0]
      if isinstance(rhs, _expr.PrimExpr):
          rhs = self.analyzer.simplify(rhs)
      if isinstance(lhs, ast.Name):
          # TODO: support defined intermediate buffer later
          lhs_ = lhs
          lhs = lhs.id
          if lhs in self.symbols.keys():
              ty, _ = self.symbols[lhs]
              _internal_assert(
                  ty != Symbol.LoopVar,
                  "Loop variable cannot be overwritten!",
              )
          decl, _, rw = self.usage[lhs]
          if decl == lhs_:
              _internal_assert(
                  lhs not in self.symbols.keys(),
                  "This value should not be defined before this point!",
              )
              if isinstance(rhs, tuple):
                  shape, dtype, scope = rhs
                  ph = tvm.te.placeholder(shape, dtype=dtype, name=lhs)
                  self.add_symbol(
                      lhs, getattr(Symbol, scope.title() + "Buffer"), ph
                  )
                  if scope == "output":
                      self.outputs.append(lhs)
                  return utils.make_nop()
              if (
                  isinstance(rhs, utils.halide_imm_types)
                  and ast.Store not in rw
              ):
                  self.add_symbol(lhs, Symbol.ConstVar, rhs)
              else:
                  _internal_assert(
                      self.device == 0,
                      "Single variable not supported in devices' side!\n"
                      + "If you are using GPU, please allocate a 'local' spad "
                      + "outside the bind body",
                  )
                  ph = tvm.te.placeholder(
                      (1,), dtype=rhs.dtype, name=lhs
                  )
                  self.add_symbol(lhs, Symbol.BufferVar, ph)
          lhs = self.visit(lhs_)
          if lhs is not None:
              buf, args = lhs
              return tvm.tir.ProducerStore(buf, rhs, args)
          return utils.make_nop()
  
      lhs, args = self.visit(lhs)
      _internal_assert(
          isinstance(lhs, Tensor),
          "An array access's LHS is expected to be a expr.Call!",
      )
      res = tvm.tir.ProducerStore(lhs, rhs, args)
      return res
  
imports: import ast
  import operator
  import logging
  import sys
  import numbers
  from enum import Enum
  from tvm.ir import Array, Range
  import tvm.runtime
  import tvm.tir
  import tvm.te
  import tvm.te._ffi_api
  import tvm.arith
  from tvm.tir import expr
  from tvm.tir import stmt
  from tvm.te.tensor import Tensor, Operation
  from tvm.tir import all
  from tvm.tir import any
  from .utils import _internal_assert
  from .None import calls
  from .None import utils
  from .preprocessor import determine_variable_usage
label_desc: Use image node_id 12 for calling the HybridParser obj's underlying member method code with example usage: obj.visit_Assign(node) and returns: res, utils, utils, tvm, utils