code: def _extract_expressions(node):
      
      if (
          isinstance(node, nodes.Call)
          and isinstance(node.func, nodes.Name)
          and node.func.name == _TRANSIENT_FUNCTION
      ):
          real_expr = node.args[0]
          real_expr.parent = node.parent
          # Search for node in all _astng_fields (the fields checked when
          # get_children is called) of its parent. Some of those fields may
          # be lists or tuples, in which case the elements need to be checked.
          # When we find it, replace it by real_expr, so that the AST looks
          # like no call to _TRANSIENT_FUNCTION ever took place.
          for name in node.parent._astroid_fields:
              child = getattr(node.parent, name)
              if isinstance(child, (list, tuple)):
                  for idx, compound_child in enumerate(child):
                      if compound_child is node:
                          child[idx] = real_expr
              elif child is node:
                  setattr(node.parent, name, real_expr)
          yield real_expr
      else:
          for child in node.get_children():
              yield from _extract_expressions(child)
docs: Find expressions in a call to _TRANSIENT_FUNCTION and extract them.
  
      The function walks the AST recursively to search for expressions that
      are wrapped into a call to _TRANSIENT_FUNCTION. If it finds such an
      expression, it completely removes the function call node from the tree,
      replacing it by the wrapped expression inside the parent.
  
      :param node: An astroid node.
      :type node:  astroid.bases.NodeNG
      :yields: The sequence of wrapped expressions on the modified tree
      expression can be found.