code: def eval_node(context, element):
      debug.dbg("eval_node %s@%s", element, element.start_pos)
      evaluator = context.evaluator
      typ = element.type
      if typ in (
          "name",
          "number",
          "string",
          "atom",
          "strings",
          "keyword",
      ):
          return eval_atom(context, element)
      elif typ == "lambdef":
          return ContextSet(
              FunctionContext.from_context(context, element)
          )
      elif typ == "expr_stmt":
          return eval_expr_stmt(context, element)
      elif typ in ("power", "atom_expr"):
          first_child = element.children[0]
          children = element.children[1:]
          had_await = False
          if (
              first_child.type == "keyword"
              and first_child.value == "await"
          ):
              had_await = True
              first_child = children.pop(0)
  
          context_set = eval_atom(context, first_child)
          for trailer in children:
              if trailer == "**":  # has a power operation.
                  right = context.eval_node(children[1])
                  context_set = _eval_comparison(
                      evaluator, context, context_set, trailer, right
                  )
                  break
              context_set = eval_trailer(context, context_set, trailer)
  
          if had_await:
              await_context_set = context_set.py__getattribute__(
                  "__await__"
              )
              if not await_context_set:
                  debug.warning(
                      "Tried to run py__await__ on context %s", context
                  )
              context_set = ContextSet()
              return _py__stop_iteration_returns(
                  await_context_set.execute_evaluated()
              )
          return context_set
      elif typ in (
          "testlist_star_expr",
          "testlist",
      ):
          # The implicit tuple in statements.
          return ContextSet(
              iterable.SequenceLiteralContext(
                  evaluator, context, element
              )
          )
      elif typ in ("not_test", "factor"):
          context_set = context.eval_node(element.children[-1])
          for operator in element.children[:-1]:
              context_set = eval_factor(context_set, operator)
          return context_set
      elif typ == "test":
          # `x if foo else y` case.
          return context.eval_node(
              element.children[0]
          ) | context.eval_node(element.children[-1])
      elif typ == "operator":
          # Must be an ellipsis, other operators are not evaluated.
          # In Python 2 ellipsis is coded as three single dot tokens, not
          # as one token 3 dot token.
          if element.value not in (".", "..."):
              origin = element.parent
              raise AssertionError(
                  "unhandled operator %s in %s "
                  % (repr(element.value), origin)
              )
          return ContextSet(
              compiled.builtin_from_name(evaluator, "Ellipsis")
          )
      elif typ == "dotted_name":
          context_set = eval_atom(context, element.children[0])
          for next_name in element.children[2::2]:
              # TODO add search_global=True?
              context_set = context_set.py__getattribute__(
                  next_name, name_context=context
              )
          return context_set
      elif typ == "eval_input":
          return eval_node(context, element.children[0])
      elif typ == "annassign":
          return pep0484._evaluate_for_annotation(
              context, element.children[1]
          )
      elif typ == "yield_expr":
          if (
              len(element.children)
              and element.children[1].type == "yield_arg"
          ):
              # Implies that it's a yield from.
              element = element.children[1].children[1]
              generators = context.eval_node(element)
              return _py__stop_iteration_returns(generators)
  
          # Generator.send() is not implemented.
          return NO_CONTEXTS
      else:
          return eval_or_test(context, element)
  
imports: import copy
  from parso.python import tree
  from jedi._compatibility import force_unicode, unicode
  from jedi import debug
  from jedi import parser_utils
  from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, ContextualizedNode, ContextualizedName, iterator_to_context_set, iterate_contexts
  from jedi.evaluate import compiled
  from jedi.evaluate import pep0484
  from jedi.evaluate import recursion
  from jedi.evaluate import helpers
  from jedi.evaluate import analysis
  from jedi.evaluate import imports
  from jedi.evaluate import arguments
  from jedi.evaluate.pep0484 import _evaluate_for_annotation
  from jedi.evaluate.context import ClassContext, FunctionContext
  from jedi.evaluate.context import iterable
  from jedi.evaluate.context import TreeInstance, CompiledInstance
  from jedi.evaluate.finder import NameFinder
  from jedi.evaluate.helpers import is_string, is_literal, is_number, is_compiled
  from jedi.evaluate.compiled.access import COMPARISON_OPERATORS
label_desc: Use image node_id 3 for calling a global function with example usage: eval_node(context, element) and returns: eval_atom, ContextSet, eval_expr_stmt, context_set, _py__stop_iteration_returns, ContextSet, context_set, unknown, ContextSet, context_set, eval_node, pep0484, NO_CONTEXTS, eval_or_test, _py__stop_iteration_returns