code: def addBinding(self, node, value):
          
          # assert value.source in (node, node.parent):
          for scope in self.scopeStack[::-1]:
              if value.name in scope:
                  break
          existing = scope.get(value.name)
  
          if (existing and not isinstance(existing, Builtin) and
                  not self.differentForks(node, existing.source)):
  
              parent_stmt = self.getParent(value.source)
              if isinstance(existing, Importation) and isinstance(parent_stmt, FOR_TYPES):
                  self.report(messages.ImportShadowedByLoopVar,
                              node, value.name, existing.source)
  
              elif scope is self.scope:
                  if (isinstance(parent_stmt, ast.comprehension) and
                          not isinstance(self.getParent(existing.source),
                                         (FOR_TYPES, ast.comprehension))):
                      self.report(messages.RedefinedInListComp,
                                  node, value.name, existing.source)
                  elif not existing.used and value.redefines(existing):
                      if value.name != '_' or isinstance(existing, Importation):
                          if not is_typing_overload(existing, self.scopeStack):
                              self.report(messages.RedefinedWhileUnused,
                                          node, value.name, existing.source)
  
              elif isinstance(existing, Importation) and value.redefines(existing):
                  existing.redefined.append(node)
  
          if value.name in self.scope:
              # then assume the rebound name is used as a global or within a loop
              value.used = self.scope[value.name].used
  
          self.scope[value.name] = value
docs: Called when a binding is altered.
  
          - `node` is the statement responsible for the change
          - `value` is the new value, a Binding instance