visit a Yield node by returning a fresh instance of it
17596
def visit_yield(self, node, parent):
        """"""
        newnode = nodes.Yield(node.lineno, node.col_offset, parent)
        if node.value is not None:
            newnode.postinit(self.visit(node.value, newnode))
        return newnode
475218
def _remove_non_propagating_yields(self):
        """"""
        for node in list(self.reassignment_nodes):
            if isinstance(node, YieldNode) and len(node.right_hand_side_variables) == 1:
                self.reassignment_nodes.remove(node)
307218
async def getNodesBy(self, full, valu, cmpr='='):
        '''
        
        '''
        async for node in self.cell.getNodesBy(full, valu, cmpr=cmpr):
            yield node.pack()
688970
def each_node(&block)
      return to_enum :each_node unless block_given?
      children_nodes.each do |child|
        child.each_node(&block)
      end
      yield self
      self
    end
615105
def visit_GeneratorExp(self, node: ast.GeneratorExp) -> Any:
        """"""
        result = self._execute_comprehension(node=node)

        for generator in node.generators:
            self.visit(generator.iter)

        # Do not set the computed value of the node since its representation would be non-informative.
        return result
138740
def visit(self, node):
        '''
        '''
        for token in self.itervisit(node):
            pass
        result = self.finalize()
        if result is not self:
            return result
512339
def visit_Return(self, node: ast.Return) -> Any:  # pylint: disable=no-self-use
        """"""
        raise AssertionError("Unexpected return node during the re-computation: {}".format(ast.dump(node)))
149968
def visit_exec(self, node, parent):
        """"""
        newnode = nodes.Exec(node.lineno, node.col_offset, parent)
        newnode.postinit(
            self.visit(node.body, newnode),
            _visit_or_none(node, "globals", self, newnode),
            _visit_or_none(node, "locals", self, newnode),
        )
        return newnode
1032284
def visit_comprehension(self, node, parent):
        """"""
        newnode = nodes.Comprehension(parent)
        newnode.postinit(
            self.visit(node.target, newnode),
            self.visit(node.iter, newnode),
            [self.visit(child, newnode) for child in node.ifs],
            getattr(node, "is_async", None),
        )
        return newnode
1196889
def visit_comprehension(self, node):
        """"""
        ifs = "".join(" if %s" % n.accept(self) for n in node.ifs)
        return "for %s in %s%s" % (
            node.target.accept(self),
            node.iter.accept(self),
            ifs,
        )
785944
def visit_global(self, node, parent):
        """"""
        newnode = nodes.Global(
            node.names,
            getattr(node, "lineno", None),
            getattr(node, "col_offset", None),
            parent,
        )
        if self._global_names:  # global at the module level, no effect
            for name in node.names:
                self._global_names[-1].setdefault(name, []).append(newnode)
        return newnode
463307
def peekiter(iterable):
    """"""
    it = iter(iterable)
    one = next(it)

    def gen():
        """Generator that returns first and proxy other items from source"""
        yield one
        while True:
            yield next(it)
    return (one, gen())
348295
def iter_chain(cur):
    
    select = "SELECT nodes FROM chain"
    for nodes, in cur.execute(select):
        yield json.loads(nodes)
545558
function visitReturnInFactory(traverse, node, path, state) {
        utils.catchup(node.range[0], state);
        utils.move(node.argument.range[0], state);
        utils.append('module.exports = ', state);
        utils.catchup(node.range[1] - 1, state);
        return false;
    }
996707
def visit_RETURN(self, node):
        
        if len(node.children) == 2:
            node.children[1] = (yield ToVisit(node.children[1]))
        yield node
817932
def visit_dictcomp(self, node, parent):
        """"""
        newnode = nodes.DictComp(node.lineno, node.col_offset, parent)
        newnode.postinit(
            self.visit(node.key, newnode),
            self.visit(node.value, newnode),
            [self.visit(child, newnode) for child in node.generators],
        )
        return newnode
1098931
def visit_generatorexp(self, node):
        """"""
        return "(%s %s)" % (
            node.elt.accept(self),
            " ".join(n.accept(self) for n in node.generators),
        )