code: def _check_name_for_execution(
      evaluator, context, compare_node, name, trailer
  ):
      from jedi.evaluate.context.function import (
          FunctionExecutionContext,
      )
  
      def create_func_excs():
          arglist = trailer.children[1]
          if arglist == ")":
              arglist = None
          args = TreeArguments(evaluator, context, arglist, trailer)
          if value_node.type == "classdef":
              created_instance = instance.TreeInstance(
                  evaluator, value.parent_context, value, args
              )
              for (
                  execution
              ) in created_instance.create_init_executions():
                  yield execution
          else:
              yield value.get_function_execution(args)
  
      for value in evaluator.goto_definitions(context, name):
          value_node = value.tree_node
          if compare_node == value_node:
              for func_execution in create_func_excs():
                  yield func_execution
          elif (
              isinstance(value.parent_context, FunctionExecutionContext)
              and compare_node.type == "funcdef"
          ):
              # Here we're trying to find decorators by checking the first
              # parameter. It's not very generic though. Should find a better
              # solution that also applies to nested decorators.
              params = value.parent_context.get_executed_params()
              if len(params) != 1:
                  continue
              values = params[0].infer()
              nodes = [v.tree_node for v in values]
              if nodes == [compare_node]:
                  # Found a decorator.
                  module_context = context.get_root_context()
                  execution_context = next(create_func_excs())
                  for name, trailer in _get_possible_nodes(
                      module_context, params[0].string_name
                  ):
                      if (
                          value_node.start_pos
                          < name.start_pos
                          < value_node.end_pos
                      ):
                          random_context = evaluator.create_context(
                              execution_context, name
                          )
                          iterator = _check_name_for_execution(
                              evaluator,
                              random_context,
                              compare_node,
                              name,
                              trailer,
                          )
                          for function_execution in iterator:
                              yield function_execution
  
imports: from parso.python import tree
  from jedi import settings
  from jedi import debug
  from jedi.evaluate.cache import evaluator_function_cache
  from jedi.evaluate import imports
  from jedi.evaluate.arguments import TreeArguments
  from jedi.evaluate.param import create_default_params
  from jedi.evaluate.helpers import is_stdlib_path
  from jedi.evaluate.utils import to_list
  from jedi.parser_utils import get_parent_scope
  from jedi.evaluate.context import ModuleContext, instance
  from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
  from jedi.evaluate import recursion
label_desc: Use image node_id 5 for calling a global function with example usage: _check_name_for_execution(evaluator, context, compare_node, name, trailer) without return types