docs: def normalize_exception(self, space):
          """Normalize the OperationError.  In other words, fix w_type and/or
          w_value to make sure that the __class__ of w_value is exactly w_type.
          """
          #
          # This method covers all ways in which the Python statement
          # "raise X, Y" can produce a valid exception type and instance.
          #
          # In the following table, 'Class' means a subclass of BaseException
          # and 'inst' is an instance of either 'Class' or a subclass of it.
          #
          # The flow object space only deals with non-advanced case.
          #
          #  input (w_type, w_value)... becomes...                advanced case?
          # ---------------------------------------------------------------------
          #  (Class, None)              (Class, Class())                no
          #  (Class, inst)              (inst.__class__, inst)          no
          #  (Class, tuple)             (Class, Class(*tuple))          yes
          #  (Class, x)                 (Class, Class(x))               no
          #  (inst, None)               (inst.__class__, inst)          no
          #
          w_type = self.w_type
          w_value = self.get_w_value(space)
  
          if space.exception_is_valid_obj_as_class_w(w_type):
              # this is for all cases of the form (Class, something)
              if space.is_w(w_value, space.w_None):
                  # raise Type: we assume we have to instantiate Type
                  w_value = space.call_function(w_type)
                  w_type = self._exception_getclass(space, w_value)
              else:
                  w_valuetype = space.exception_getclass(w_value)
                  if space.exception_issubclass_w(w_valuetype, w_type):
                      # raise Type, Instance: let etype be the exact type of value
                      w_type = w_valuetype
                  else:
                      if space.isinstance_w(w_value, space.w_tuple):
                          # raise Type, tuple: assume the tuple contains the
                          #                    constructor args
                          w_value = space.call(w_type, w_value)
                      else:
                          # raise Type, X: assume X is the constructor argument
                          w_value = space.call_function(w_type, w_value)
                      w_type = self._exception_getclass(space, w_value)
              if self.w_cause:
                  # ensure w_cause is of a valid type
                  if space.is_none(self.w_cause):
                      pass
                  else:
                      self._exception_getclass(space, self.w_cause, "exception causes")
                  space.setattr(w_value, space.wrap("__cause__"), self.w_cause)
              if self._application_traceback:
                  from pypy.interpreter.pytraceback import PyTraceback
                  from pypy.module.exceptions.interp_exceptions import W_BaseException
                  tb = self._application_traceback
                  if (isinstance(w_value, W_BaseException) and
                      isinstance(tb, PyTraceback)):
                      # traceback hasn't escaped yet
                      w_value.w_traceback = tb
                  else:
                      # traceback has escaped
                      space.setattr(w_value, space.wrap("__traceback__"),
                                    space.wrap(self.get_traceback()))
          else:
              # the only case left here is (inst, None), from a 'raise inst'.
              w_inst = w_type
              w_instclass = self._exception_getclass(space, w_inst)
              if not space.is_w(w_value, space.w_None):
                  raise OperationError(space.w_TypeError,
                                       space.wrap("instance exception may not "
                                                  "have a separate value"))
              w_value = w_inst
              w_type = w_instclass
  
          self.w_type = w_type
          self._w_value = w_value