class_docstr: This class is used to evaluate functions and their returns.
  
  This is the most complicated class, because it contains the logic to
  transfer parameters. It is even more complicated, because there may be
  multiple calls to functions and recursion has to be avoided. But this is
  responsibility of the decorators.
class_docstr_tok: ["This","class","is","used","to","evaluate","functions","and","their","returns",".","This","is","the","most","complicated","class",",","because","it","contains","the","logic","to","transfer","parameters",".","It","is","even","more","complicated",",","because","there","may","be","multiple","calls","to","functions","and","recursion","has","to","be","avoided",".","But","this","is","responsibility","of","the","decorators","."]
code: def get_yield_lazy_contexts(self, is_async=False):
      # TODO: if is_async, wrap yield statements in Awaitable/async_generator_asend
      for_parents = [
          (
              y,
              tree.search_ancestor(
                  y, "for_stmt", "funcdef", "while_stmt", "if_stmt"
              ),
          )
          for y in get_yield_exprs(self.evaluator, self.tree_node)
      ]
  
      # Calculate if the yields are placed within the same for loop.
      yields_order = []
      last_for_stmt = None
      for yield_, for_stmt in for_parents:
          # For really simple for loops we can predict the order. Otherwise
          # we just ignore it.
          parent = for_stmt.parent
          if parent.type == "suite":
              parent = parent.parent
          if (
              for_stmt.type == "for_stmt"
              and parent == self.tree_node
              and parser_utils.for_stmt_defines_one_name(for_stmt)
          ):  # Simplicity for now.
              if for_stmt == last_for_stmt:
                  yields_order[-1][1].append(yield_)
              else:
                  yields_order.append((for_stmt, [yield_]))
          elif for_stmt == self.tree_node:
              yields_order.append((None, [yield_]))
          else:
              types = self.get_return_values(check_yields=True)
              if types:
                  yield LazyKnownContexts(types)
              return
          last_for_stmt = for_stmt
  
      for for_stmt, yields in yields_order:
          if for_stmt is None:
              # No for_stmt, just normal yields.
              for yield_ in yields:
                  for result in self._get_yield_lazy_context(yield_):
                      yield result
          else:
              input_node = for_stmt.get_testlist()
              cn = ContextualizedNode(self, input_node)
              ordered = cn.infer().iterate(cn)
              ordered = list(ordered)
              for lazy_context in ordered:
                  dct = {
                      str(
                          for_stmt.children[1].value
                      ): lazy_context.infer()
                  }
                  with helpers.predefine_names(self, for_stmt, dct):
                      for yield_in_same_for_stmt in yields:
                          for result in self._get_yield_lazy_context(
                              yield_in_same_for_stmt
                          ):
                              yield result
  
imports: from parso.python import tree
  from jedi._compatibility import use_metaclass
  from jedi import debug
  from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass
  from jedi.evaluate import compiled
  from jedi.evaluate import recursion
  from jedi.evaluate import docstrings
  from jedi.evaluate import pep0484
  from jedi.evaluate import flow_analysis
  from jedi.evaluate import helpers
  from jedi.evaluate.arguments import AnonymousArguments
  from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter, ContextName, AbstractNameDefinition, ParamName
  from jedi.evaluate.base_context import ContextualizedNode, NO_CONTEXTS, ContextSet, TreeContext
  from jedi.evaluate.lazy_context import LazyKnownContexts, LazyKnownContext, LazyTreeContext
  from jedi.evaluate.context import iterable
  from jedi.evaluate.context import asynchronous
  from jedi import parser_utils
  from jedi.evaluate.parser_cache import get_yield_exprs
label_desc: Use image node_id 4 for calling the FunctionExecutionContext obj's underlying member method code with example usage: obj.get_yield_lazy_contexts(is_async) without return types