code: def infer_call_result(self, caller=None, context=None):
          
          if self.is_generator():
              if isinstance(self, AsyncFunctionDef):
                  generator_cls = bases.AsyncGenerator
              else:
                  generator_cls = bases.Generator
              result = generator_cls(self)
              yield result
              return
          # This is really a gigantic hack to work around metaclass generators
          # that return transient class-generating functions. Pylint's AST structure
          # cannot handle a base class object that is only used for calling __new__,
          # but does not contribute to the inheritance structure itself. We inject
          # a fake class into the hierarchy here for several well-known metaclass
          # generators, and filter it out later.
          if (
              self.name == "with_metaclass"
              and len(self.args.args) == 1
              and self.args.vararg is not None
          ):
              metaclass = next(caller.args[0].infer(context))
              if isinstance(metaclass, ClassDef):
                  class_bases = [next(arg.infer(context)) for arg in caller.args[1:]]
                  new_class = ClassDef(name="temporary_class")
                  new_class.hide = True
                  new_class.parent = self
                  new_class.postinit(
                      bases=[base for base in class_bases if base != util.Uninferable],
                      body=[],
                      decorators=[],
                      metaclass=metaclass,
                  )
                  yield new_class
                  return
          returns = self._get_return_nodes_skip_functions()
  
          first_return = next(returns, None)
          if not first_return:
              raise exceptions.InferenceError("Empty return iterator")
  
          for returnnode in itertools.chain((first_return,), returns):
              if returnnode.value is None:
                  yield node_classes.Const(None)
              else:
                  try:
                      yield from returnnode.value.infer(context)
                  except exceptions.InferenceError:
                      yield util.Uninferable
docs: Infer what the function returns when called.
  
          :returns: What the function returns.
          :rtype: iterable(NodeNG or Uninferable) or None