code: def eval_element(self, context, element):
      if not self.infer_enabled:
          return NO_CONTEXTS
  
      if isinstance(context, CompForContext):
          return eval_node(context, element)
  
      if_stmt = element
      while if_stmt is not None:
          if_stmt = if_stmt.parent
          if if_stmt.type in ("if_stmt", "for_stmt"):
              break
          if parser_utils.is_scope(if_stmt):
              if_stmt = None
              break
      predefined_if_name_dict = context.predefined_names.get(if_stmt)
      # TODO there's a lot of issues with this one. We actually should do
      # this in a different way. Caching should only be active in certain
      # cases and this all sucks.
      if (
          predefined_if_name_dict is None
          and if_stmt
          and if_stmt.type == "if_stmt"
          and self.is_analysis
      ):
          if_stmt_test = if_stmt.children[1]
          name_dicts = [{}]
          # If we already did a check, we don't want to do it again -> If
          # context.predefined_names is filled, we stop.
          # We don't want to check the if stmt itself, it's just about
          # the content.
          if element.start_pos > if_stmt_test.end_pos:
              # Now we need to check if the names in the if_stmt match the
              # names in the suite.
              if_names = helpers.get_names_of_node(if_stmt_test)
              element_names = helpers.get_names_of_node(element)
              str_element_names = [e.value for e in element_names]
              if any(i.value in str_element_names for i in if_names):
                  for if_name in if_names:
                      definitions = self.goto_definitions(
                          context, if_name
                      )
                      # Every name that has multiple different definitions
                      # causes the complexity to rise. The complexity should
                      # never fall below 1.
                      if len(definitions) > 1:
                          if len(name_dicts) * len(definitions) > 16:
                              debug.dbg(
                                  "Too many options for if branch evaluation %s.",
                                  if_stmt,
                              )
                              # There's only a certain amount of branches
                              # Jedi can evaluate, otherwise it will take to
                              # long.
                              name_dicts = [{}]
                              break
  
                          original_name_dicts = list(name_dicts)
                          name_dicts = []
                          for definition in definitions:
                              new_name_dicts = list(original_name_dicts)
                              for i, name_dict in enumerate(
                                  new_name_dicts
                              ):
                                  new_name_dicts[i] = name_dict.copy()
                                  new_name_dicts[i][
                                      if_name.value
                                  ] = ContextSet(definition)
  
                              name_dicts += new_name_dicts
                      else:
                          for name_dict in name_dicts:
                              name_dict[if_name.value] = definitions
          if len(name_dicts) > 1:
              result = ContextSet()
              for name_dict in name_dicts:
                  with helpers.predefine_names(
                      context, if_stmt, name_dict
                  ):
                      result |= eval_node(context, element)
              return result
          else:
              return self._eval_element_if_evaluated(context, element)
      else:
          if predefined_if_name_dict:
              return eval_node(context, element)
          else:
              return self._eval_element_if_evaluated(context, element)
  
imports: from parso.python import tree
  import parso
  from parso import python_bytes_to_unicode
  from jedi import debug
  from jedi import parser_utils
  from jedi.evaluate.utils import unite
  from jedi.evaluate import imports
  from jedi.evaluate import recursion
  from jedi.evaluate.cache import evaluator_function_cache
  from jedi.evaluate import compiled
  from jedi.evaluate import helpers
  from jedi.evaluate.filters import TreeNameDefinition, ParamName
  from jedi.evaluate.base_context import ContextualizedName, ContextualizedNode, ContextSet, NO_CONTEXTS, iterate_contexts
  from jedi.evaluate.context import ClassContext, FunctionContext, AnonymousInstance, BoundMethod
  from jedi.evaluate.context.iterable import CompForContext
  from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, eval_node, check_tuple_assignments
label_desc: Use image node_id 5 for calling the Evaluator obj's underlying member method code with example usage: obj.eval_element(context, element) and returns: NO_CONTEXTS, eval_node, result, self, eval_node, self