code: def infer_call_result(self, caller, context):
          
  
          # If we're unbound method __new__ of builtin object, the result is an
          # instance of the class given as first argument.
          if (
              self._proxied.name == "__new__"
              and self._proxied.parent.frame().qname() == "%s.object" % BUILTINS
          ):
              if caller.args:
                  node_context = context.extra_context.get(caller.args[0])
                  infer = caller.args[0].infer(context=node_context)
              else:
                  infer = []
              return (Instance(x) if x is not util.Uninferable else x for x in infer)
          return self._proxied.infer_call_result(caller, context)
docs: The boundnode of the regular context with a function called
          on ``object.__new__`` will be of type ``object``,
          which is incorrect for the argument in general.
          If no context is given the ``object.__new__`` call argument will
          correctly inferred except when inside a call that requires
          the additional context (such as a classmethod) of the boundnode
          to determine which class the method was called from