path: root/contrib/tools/cython/Cython/Compiler/FlowControl.py

from __future__ import absolute_import 
 
import cython 
cython.declare(PyrexTypes=object, ExprNodes=object, Nodes=object, 
               Builtin=object, InternalError=object, error=object, warning=object,
               py_object_type=object, unspecified_type=object, 
               object_expr=object, fake_rhs_expr=object, TypedExprNode=object) 
 
from . import Builtin 
from . import ExprNodes 
from . import Nodes 
from . import Options 
from .PyrexTypes import py_object_type, unspecified_type 
from . import PyrexTypes 
 
from .Visitor import TreeVisitor, CythonTransform 
from .Errors import error, warning, InternalError 
from .Optimize import ConstantFolding
 

class TypedExprNode(ExprNodes.ExprNode): 
    # Used for declaring assignments of a specified type without a known entry. 
    def __init__(self, type, may_be_none=None, pos=None): 
        super(TypedExprNode, self).__init__(pos) 
        self.type = type 
        self._may_be_none = may_be_none 
 
    def may_be_none(self): 
        return self._may_be_none != False 
 
object_expr = TypedExprNode(py_object_type, may_be_none=True) 
# Fake rhs to silence "unused variable" warning 
fake_rhs_expr = TypedExprNode(unspecified_type) 
 
 
class ControlBlock(object): 
    """Control flow graph node. Sequence of assignments and name references. 
 
       children  set of children nodes 
       parents   set of parent nodes 
       positions set of position markers 
 
       stats     list of block statements 
       gen       dict of assignments generated by this block 
       bounded   set  of entries that are definitely bounded in this block 
 
       Example: 
 
        a = 1 
        b = a + c # 'c' is already bounded or exception here 
 
        stats = [Assignment(a), NameReference(a), NameReference(c), 
                     Assignment(b)] 
        gen = {Entry(a): Assignment(a), Entry(b): Assignment(b)} 
        bounded = set([Entry(a), Entry(c)]) 
 
    """ 
 
    def __init__(self): 
        self.children = set() 
        self.parents = set() 
        self.positions = set() 
 
        self.stats = [] 
        self.gen = {} 
        self.bounded = set() 
 
        self.i_input = 0 
        self.i_output = 0 
        self.i_gen = 0 
        self.i_kill = 0 
        self.i_state = 0 
 
    def empty(self): 
        return (not self.stats and not self.positions) 
 
    def detach(self): 
        """Detach block from parents and children.""" 
        for child in self.children: 
            child.parents.remove(self) 
        for parent in self.parents: 
            parent.children.remove(self) 
        self.parents.clear() 
        self.children.clear() 
 
    def add_child(self, block): 
        self.children.add(block) 
        block.parents.add(self) 
 
 
class ExitBlock(ControlBlock): 
    """Non-empty exit point block.""" 
 
    def empty(self): 
        return False 
 
 
class AssignmentList(object): 
    def __init__(self): 
        self.stats = [] 
 
 
class ControlFlow(object): 
    """Control-flow graph. 
 
       entry_point ControlBlock entry point for this graph 
       exit_point  ControlBlock normal exit point 
       block       ControlBlock current block 
       blocks      set    children nodes 
       entries     set    tracked entries 
       loops       list   stack for loop descriptors 
       exceptions  list   stack for exception descriptors 
    """ 
 
    def __init__(self): 
        self.blocks = set() 
        self.entries = set() 
        self.loops = [] 
        self.exceptions = [] 
 
        self.entry_point = ControlBlock() 
        self.exit_point = ExitBlock() 
        self.blocks.add(self.exit_point) 
        self.block = self.entry_point 
 
    def newblock(self, parent=None): 
        """Create floating block linked to `parent` if given. 
 
           NOTE: Block is NOT added to self.blocks 
        """ 
        block = ControlBlock() 
        self.blocks.add(block) 
        if parent: 
            parent.add_child(block) 
        return block 
 
    def nextblock(self, parent=None): 
        """Create block children block linked to current or `parent` if given. 
 
           NOTE: Block is added to self.blocks 
        """ 
        block = ControlBlock() 
        self.blocks.add(block) 
        if parent: 
            parent.add_child(block) 
        elif self.block: 
            self.block.add_child(block) 
        self.block = block 
        return self.block 
 
    def is_tracked(self, entry): 
        if entry.is_anonymous: 
            return False 
        return (entry.is_local or entry.is_pyclass_attr or entry.is_arg or 
                entry.from_closure or entry.in_closure or 
                entry.error_on_uninitialized) 
 
    def is_statically_assigned(self, entry): 
        if (entry.is_local and entry.is_variable and 
                (entry.type.is_struct_or_union or 
                 entry.type.is_complex or 
                 entry.type.is_array or 
                 entry.type.is_cpp_class)): 
            # stack allocated structured variable => never uninitialised 
            return True 
        return False 
 
    def mark_position(self, node): 
        """Mark position, will be used to draw graph nodes.""" 
        if self.block: 
            self.block.positions.add(node.pos[:2]) 
 
    def mark_assignment(self, lhs, rhs, entry): 
        if self.block and self.is_tracked(entry): 
            assignment = NameAssignment(lhs, rhs, entry) 
            self.block.stats.append(assignment) 
            self.block.gen[entry] = assignment 
            self.entries.add(entry) 
 
    def mark_argument(self, lhs, rhs, entry): 
        if self.block and self.is_tracked(entry): 
            assignment = Argument(lhs, rhs, entry) 
            self.block.stats.append(assignment) 
            self.block.gen[entry] = assignment 
            self.entries.add(entry) 
 
    def mark_deletion(self, node, entry): 
        if self.block and self.is_tracked(entry): 
            assignment = NameDeletion(node, entry) 
            self.block.stats.append(assignment) 
            self.block.gen[entry] = Uninitialized 
            self.entries.add(entry) 
 
    def mark_reference(self, node, entry): 
        if self.block and self.is_tracked(entry): 
            self.block.stats.append(NameReference(node, entry)) 
            ## XXX: We don't track expression evaluation order so we can't use 
            ## XXX: successful reference as initialization sign. 
            ## # Local variable is definitely bound after this reference 
            ## if not node.allow_null: 
            ##     self.block.bounded.add(entry) 
            self.entries.add(entry) 
 
    def normalize(self): 
        """Delete unreachable and orphan blocks.""" 
        queue = set([self.entry_point]) 
        visited = set() 
        while queue: 
            root = queue.pop() 
            visited.add(root) 
            for child in root.children: 
                if child not in visited: 
                    queue.add(child) 
        unreachable = self.blocks - visited 
        for block in unreachable: 
            block.detach() 
        visited.remove(self.entry_point) 
        for block in visited: 
            if block.empty(): 
                for parent in block.parents: # Re-parent 
                    for child in block.children: 
                        parent.add_child(child) 
                block.detach() 
                unreachable.add(block) 
        self.blocks -= unreachable 
 
    def initialize(self): 
        """Set initial state, map assignments to bits.""" 
        self.assmts = {} 
 
        bit = 1 
        for entry in self.entries: 
            assmts = AssignmentList() 
            assmts.mask = assmts.bit = bit 
            self.assmts[entry] = assmts 
            bit <<= 1 
 
        for block in self.blocks: 
            for stat in block.stats: 
                if isinstance(stat, NameAssignment): 
                    stat.bit = bit 
                    assmts = self.assmts[stat.entry] 
                    assmts.stats.append(stat) 
                    assmts.mask |= bit 
                    bit <<= 1 
 
        for block in self.blocks: 
            for entry, stat in block.gen.items(): 
                assmts = self.assmts[entry] 
                if stat is Uninitialized: 
                    block.i_gen |= assmts.bit 
                else: 
                    block.i_gen |= stat.bit 
                block.i_kill |= assmts.mask 
            block.i_output = block.i_gen 
            for entry in block.bounded: 
                block.i_kill |= self.assmts[entry].bit 
 
        for assmts in self.assmts.values():
            self.entry_point.i_gen |= assmts.bit 
        self.entry_point.i_output = self.entry_point.i_gen 
 
    def map_one(self, istate, entry): 
        ret = set() 
        assmts = self.assmts[entry] 
        if istate & assmts.bit: 
            if self.is_statically_assigned(entry): 
                ret.add(StaticAssignment(entry)) 
            elif entry.from_closure: 
                ret.add(Unknown) 
            else: 
                ret.add(Uninitialized) 
        for assmt in assmts.stats: 
            if istate & assmt.bit: 
                ret.add(assmt) 
        return ret 
 
    def reaching_definitions(self): 
        """Per-block reaching definitions analysis.""" 
        dirty = True 
        while dirty: 
            dirty = False 
            for block in self.blocks: 
                i_input = 0 
                for parent in block.parents: 
                    i_input |= parent.i_output 
                i_output = (i_input & ~block.i_kill) | block.i_gen 
                if i_output != block.i_output: 
                    dirty = True 
                block.i_input = i_input 
                block.i_output = i_output 
 
 
class LoopDescr(object): 
    def __init__(self, next_block, loop_block): 
        self.next_block = next_block 
        self.loop_block = loop_block 
        self.exceptions = [] 
 
 
class ExceptionDescr(object): 
    """Exception handling helper. 
 
    entry_point   ControlBlock Exception handling entry point 
    finally_enter ControlBlock Normal finally clause entry point 
    finally_exit  ControlBlock Normal finally clause exit point 
    """ 
 
    def __init__(self, entry_point, finally_enter=None, finally_exit=None): 
        self.entry_point = entry_point 
        self.finally_enter = finally_enter 
        self.finally_exit = finally_exit 
 
 
class NameAssignment(object): 
    def __init__(self, lhs, rhs, entry): 
        if lhs.cf_state is None: 
            lhs.cf_state = set() 
        self.lhs = lhs 
        self.rhs = rhs 
        self.entry = entry 
        self.pos = lhs.pos 
        self.refs = set() 
        self.is_arg = False 
        self.is_deletion = False 
        self.inferred_type = None 
 
    def __repr__(self): 
        return '%s(entry=%r)' % (self.__class__.__name__, self.entry) 
 
    def infer_type(self): 
        self.inferred_type = self.rhs.infer_type(self.entry.scope) 
        return self.inferred_type 
 
    def type_dependencies(self): 
        return self.rhs.type_dependencies(self.entry.scope) 
 
    @property 
    def type(self): 
        if not self.entry.type.is_unspecified: 
            return self.entry.type 
        return self.inferred_type 
 
 
class StaticAssignment(NameAssignment): 
    """Initialised at declaration time, e.g. stack allocation.""" 
    def __init__(self, entry): 
        if not entry.type.is_pyobject: 
            may_be_none = False 
        else: 
            may_be_none = None  # unknown 
        lhs = TypedExprNode( 
            entry.type, may_be_none=may_be_none, pos=entry.pos) 
        super(StaticAssignment, self).__init__(lhs, lhs, entry) 
 
    def infer_type(self): 
        return self.entry.type 
 
    def type_dependencies(self): 
        return () 
 
 
class Argument(NameAssignment): 
    def __init__(self, lhs, rhs, entry): 
        NameAssignment.__init__(self, lhs, rhs, entry) 
        self.is_arg = True 
 
 
class NameDeletion(NameAssignment): 
    def __init__(self, lhs, entry): 
        NameAssignment.__init__(self, lhs, lhs, entry) 
        self.is_deletion = True 
 
    def infer_type(self): 
        inferred_type = self.rhs.infer_type(self.entry.scope) 
        if (not inferred_type.is_pyobject and 
            inferred_type.can_coerce_to_pyobject(self.entry.scope)): 
            return py_object_type 
        self.inferred_type = inferred_type 
        return inferred_type 
 
 
class Uninitialized(object): 
    """Definitely not initialised yet.""" 
 
 
class Unknown(object): 
    """Coming from outer closure, might be initialised or not.""" 
 
 
class NameReference(object): 
    def __init__(self, node, entry): 
        if node.cf_state is None: 
            node.cf_state = set() 
        self.node = node 
        self.entry = entry 
        self.pos = node.pos 
 
    def __repr__(self): 
        return '%s(entry=%r)' % (self.__class__.__name__, self.entry) 
 
 
class ControlFlowState(list): 
    # Keeps track of Node's entry assignments 
    # 
    # cf_is_null        [boolean] It is uninitialized 
    # cf_maybe_null     [boolean] May be uninitialized 
    # is_single         [boolean] Has only one assignment at this point 
 
    cf_maybe_null = False 
    cf_is_null = False 
    is_single = False 
 
    def __init__(self, state): 
        if Uninitialized in state: 
            state.discard(Uninitialized) 
            self.cf_maybe_null = True 
            if not state: 
                self.cf_is_null = True 
        elif Unknown in state: 
            state.discard(Unknown) 
            self.cf_maybe_null = True 
        else: 
            if len(state) == 1: 
                self.is_single = True 
        # XXX: Remove fake_rhs_expr 
        super(ControlFlowState, self).__init__( 
            [i for i in state if i.rhs is not fake_rhs_expr]) 
 
    def one(self): 
        return self[0] 
 
 
class GVContext(object): 
    """Graphviz subgraph object.""" 
 
    def __init__(self): 
        self.blockids = {} 
        self.nextid = 0 
        self.children = [] 
        self.sources = {} 
 
    def add(self, child): 
        self.children.append(child) 
 
    def nodeid(self, block): 
        if block not in self.blockids: 
            self.blockids[block] = 'block%d' % self.nextid 
            self.nextid += 1 
        return self.blockids[block] 
 
    def extract_sources(self, block): 
        if not block.positions: 
            return '' 
        start = min(block.positions) 
        stop = max(block.positions) 
        srcdescr = start[0] 
        if not srcdescr in self.sources: 
            self.sources[srcdescr] = list(srcdescr.get_lines()) 
        lines = self.sources[srcdescr] 
        return '\\n'.join([l.strip() for l in lines[start[1] - 1:stop[1]]]) 
 
    def render(self, fp, name, annotate_defs=False): 
        """Render graphviz dot graph""" 
        fp.write('digraph %s {\n' % name) 
        fp.write(' node [shape=box];\n') 
        for child in self.children: 
            child.render(fp, self, annotate_defs) 
        fp.write('}\n') 
 
    def escape(self, text): 
        return text.replace('"', '\\"').replace('\n', '\\n') 
 
 
class GV(object): 
    """Graphviz DOT renderer.""" 
 
    def __init__(self, name, flow): 
        self.name = name 
        self.flow = flow 
 
    def render(self, fp, ctx, annotate_defs=False): 
        fp.write(' subgraph %s {\n' % self.name) 
        for block in self.flow.blocks: 
            label = ctx.extract_sources(block) 
            if annotate_defs: 
                for stat in block.stats: 
                    if isinstance(stat, NameAssignment): 
                        label += '\n %s [%s %s]' % (
                            stat.entry.name, 'deletion' if stat.is_deletion else 'definition', stat.pos[1])
                    elif isinstance(stat, NameReference): 
                        if stat.entry: 
                            label += '\n %s [reference %s]' % (stat.entry.name, stat.pos[1])
            if not label: 
                label = 'empty' 
            pid = ctx.nodeid(block) 
            fp.write('  %s [label="%s"];\n' % (pid, ctx.escape(label))) 
        for block in self.flow.blocks: 
            pid = ctx.nodeid(block) 
            for child in block.children: 
                fp.write('  %s -> %s;\n' % (pid, ctx.nodeid(child))) 
        fp.write(' }\n') 
 
 
class MessageCollection(object): 
    """Collect error/warnings messages first then sort""" 
    def __init__(self): 
        self.messages = set()
 
    def error(self, pos, message): 
        self.messages.add((pos, True, message))
 
    def warning(self, pos, message): 
        self.messages.add((pos, False, message))
 
    def report(self): 
        for pos, is_error, message in sorted(self.messages):
            if is_error: 
                error(pos, message) 
            else: 
                warning(pos, message, 2) 
 
 
def check_definitions(flow, compiler_directives): 
    flow.initialize() 
    flow.reaching_definitions() 
 
    # Track down state 
    assignments = set() 
    # Node to entry map 
    references = {} 
    assmt_nodes = set() 
 
    for block in flow.blocks: 
        i_state = block.i_input 
        for stat in block.stats: 
            i_assmts = flow.assmts[stat.entry] 
            state = flow.map_one(i_state, stat.entry) 
            if isinstance(stat, NameAssignment): 
                stat.lhs.cf_state.update(state) 
                assmt_nodes.add(stat.lhs) 
                i_state = i_state & ~i_assmts.mask 
                if stat.is_deletion: 
                    i_state |= i_assmts.bit 
                else: 
                    i_state |= stat.bit 
                assignments.add(stat) 
                if stat.rhs is not fake_rhs_expr: 
                    stat.entry.cf_assignments.append(stat) 
            elif isinstance(stat, NameReference): 
                references[stat.node] = stat.entry 
                stat.entry.cf_references.append(stat) 
                stat.node.cf_state.update(state) 
                ## if not stat.node.allow_null: 
                ##     i_state &= ~i_assmts.bit 
                ## # after successful read, the state is known to be initialised 
                state.discard(Uninitialized) 
                state.discard(Unknown) 
                for assmt in state: 
                    assmt.refs.add(stat) 
 
    # Check variable usage 
    warn_maybe_uninitialized = compiler_directives['warn.maybe_uninitialized'] 
    warn_unused_result = compiler_directives['warn.unused_result'] 
    warn_unused = compiler_directives['warn.unused'] 
    warn_unused_arg = compiler_directives['warn.unused_arg'] 
 
    messages = MessageCollection() 
 
    # assignment hints 
    for node in assmt_nodes: 
        if Uninitialized in node.cf_state: 
            node.cf_maybe_null = True 
            if len(node.cf_state) == 1: 
                node.cf_is_null = True 
            else: 
                node.cf_is_null = False 
        elif Unknown in node.cf_state: 
            node.cf_maybe_null = True 
        else: 
            node.cf_is_null = False 
            node.cf_maybe_null = False 
 
    # Find uninitialized references and cf-hints 
    for node, entry in references.items():
        if Uninitialized in node.cf_state: 
            node.cf_maybe_null = True 
            if not entry.from_closure and len(node.cf_state) == 1: 
                node.cf_is_null = True 
            if (node.allow_null or entry.from_closure 
                    or entry.is_pyclass_attr or entry.type.is_error):
                pass  # Can be uninitialized here
            elif node.cf_is_null: 
                if entry.error_on_uninitialized or ( 
                        Options.error_on_uninitialized and ( 
                        entry.type.is_pyobject or entry.type.is_unspecified)): 
                    messages.error( 
                        node.pos, 
                        "local variable '%s' referenced before assignment" 
                        % entry.name) 
                else: 
                    messages.warning( 
                        node.pos, 
                        "local variable '%s' referenced before assignment" 
                        % entry.name) 
            elif warn_maybe_uninitialized: 
                messages.warning( 
                    node.pos, 
                    "local variable '%s' might be referenced before assignment" 
                    % entry.name) 
        elif Unknown in node.cf_state: 
            # TODO: better cross-closure analysis to know when inner functions 
            #       are being called before a variable is being set, and when 
            #       a variable is known to be set before even defining the 
            #       inner function, etc. 
            node.cf_maybe_null = True 
        else: 
            node.cf_is_null = False 
            node.cf_maybe_null = False 
 
    # Unused result 
    for assmt in assignments: 
        if (not assmt.refs and not assmt.entry.is_pyclass_attr 
            and not assmt.entry.in_closure): 
            if assmt.entry.cf_references and warn_unused_result: 
                if assmt.is_arg: 
                    messages.warning(assmt.pos, "Unused argument value '%s'" % 
                                     assmt.entry.name) 
                else: 
                    messages.warning(assmt.pos, "Unused result in '%s'" % 
                                     assmt.entry.name) 
            assmt.lhs.cf_used = False 
 
    # Unused entries 
    for entry in flow.entries: 
        if (not entry.cf_references 
                and not entry.is_pyclass_attr): 
            if entry.name != '_' and not entry.name.startswith('unused'):
                # '_' is often used for unused variables, e.g. in loops 
                if entry.is_arg: 
                    if warn_unused_arg: 
                        messages.warning(entry.pos, "Unused argument '%s'" % 
                                         entry.name) 
                else: 
                    if warn_unused: 
                        messages.warning(entry.pos, "Unused entry '%s'" % 
                                         entry.name) 
            entry.cf_used = False 
 
    messages.report() 
 
    for node in assmt_nodes: 
        node.cf_state = ControlFlowState(node.cf_state) 
    for node in references: 
        node.cf_state = ControlFlowState(node.cf_state) 
 
 
class AssignmentCollector(TreeVisitor): 
    def __init__(self): 
        super(AssignmentCollector, self).__init__() 
        self.assignments = [] 
 
    def visit_Node(self): 
        self._visitchildren(self, None) 
 
    def visit_SingleAssignmentNode(self, node): 
        self.assignments.append((node.lhs, node.rhs)) 
 
    def visit_CascadedAssignmentNode(self, node): 
        for lhs in node.lhs_list: 
            self.assignments.append((lhs, node.rhs)) 
 
 
class ControlFlowAnalysis(CythonTransform): 
 
    def visit_ModuleNode(self, node): 
        self.gv_ctx = GVContext() 
        self.constant_folder = ConstantFolding()
 
        # Set of NameNode reductions 
        self.reductions = set() 
 
        self.in_inplace_assignment = False 
        self.env_stack = [] 
        self.env = node.scope 
        self.stack = [] 
        self.flow = ControlFlow() 
        self.visitchildren(node) 
 
        check_definitions(self.flow, self.current_directives) 
 
        dot_output = self.current_directives['control_flow.dot_output'] 
        if dot_output: 
            annotate_defs = self.current_directives['control_flow.dot_annotate_defs'] 
            fp = open(dot_output, 'wt') 
            try: 
                self.gv_ctx.render(fp, 'module', annotate_defs=annotate_defs) 
            finally: 
                fp.close() 
        return node 
 
    def visit_FuncDefNode(self, node): 
        for arg in node.args: 
            if arg.default: 
                self.visitchildren(arg) 
        self.visitchildren(node, ('decorators',)) 
        self.env_stack.append(self.env) 
        self.env = node.local_scope 
        self.stack.append(self.flow) 
        self.flow = ControlFlow() 
 
        # Collect all entries 
        for entry in node.local_scope.entries.values(): 
            if self.flow.is_tracked(entry): 
                self.flow.entries.add(entry) 
 
        self.mark_position(node) 
        # Function body block 
        self.flow.nextblock() 
 
        for arg in node.args: 
            self._visit(arg) 
        if node.star_arg: 
            self.flow.mark_argument(node.star_arg, 
                                    TypedExprNode(Builtin.tuple_type, 
                                                  may_be_none=False), 
                                    node.star_arg.entry) 
        if node.starstar_arg: 
            self.flow.mark_argument(node.starstar_arg, 
                                    TypedExprNode(Builtin.dict_type, 
                                                  may_be_none=False), 
                                    node.starstar_arg.entry) 
        self._visit(node.body) 
        # Workaround for generators 
        if node.is_generator: 
            self._visit(node.gbody.body) 
 
        # Exit point 
        if self.flow.block: 
            self.flow.block.add_child(self.flow.exit_point) 
 
        # Cleanup graph 
        self.flow.normalize() 
        check_definitions(self.flow, self.current_directives) 
        self.flow.blocks.add(self.flow.entry_point) 
 
        self.gv_ctx.add(GV(node.local_scope.name, self.flow)) 
 
        self.flow = self.stack.pop() 
        self.env = self.env_stack.pop() 
        return node 
 
    def visit_DefNode(self, node): 
        node.used = True 
        return self.visit_FuncDefNode(node) 
 
    def visit_GeneratorBodyDefNode(self, node): 
        return node 
 
    def visit_CTypeDefNode(self, node): 
        return node 
 
    def mark_assignment(self, lhs, rhs=None): 
        if not self.flow.block: 
            return 
        if self.flow.exceptions: 
            exc_descr = self.flow.exceptions[-1] 
            self.flow.block.add_child(exc_descr.entry_point) 
            self.flow.nextblock() 
 
        if not rhs: 
            rhs = object_expr 
        if lhs.is_name: 
            if lhs.entry is not None: 
                entry = lhs.entry 
            else: 
                entry = self.env.lookup(lhs.name) 
            if entry is None: # TODO: This shouldn't happen... 
                return 
            self.flow.mark_assignment(lhs, rhs, entry) 
        elif lhs.is_sequence_constructor:
            for i, arg in enumerate(lhs.args):
                if not rhs or arg.is_starred:
                    item_node = None
                else:
                    item_node = rhs.inferable_item_node(i)
                self.mark_assignment(arg, item_node)
        else: 
            self._visit(lhs) 
 
        if self.flow.exceptions: 
            exc_descr = self.flow.exceptions[-1] 
            self.flow.block.add_child(exc_descr.entry_point) 
            self.flow.nextblock() 
 
    def mark_position(self, node): 
        """Mark position if DOT output is enabled.""" 
        if self.current_directives['control_flow.dot_output']: 
            self.flow.mark_position(node) 
 
    def visit_FromImportStatNode(self, node): 
        for name, target in node.items: 
            if name != "*": 
                self.mark_assignment(target) 
        self.visitchildren(node) 
        return node 
 
    def visit_AssignmentNode(self, node): 
        raise InternalError("Unhandled assignment node") 
 
    def visit_SingleAssignmentNode(self, node): 
        self._visit(node.rhs) 
        self.mark_assignment(node.lhs, node.rhs) 
        return node 
 
    def visit_CascadedAssignmentNode(self, node): 
        self._visit(node.rhs) 
        for lhs in node.lhs_list: 
            self.mark_assignment(lhs, node.rhs) 
        return node 
 
    def visit_ParallelAssignmentNode(self, node): 
        collector = AssignmentCollector() 
        collector.visitchildren(node) 
        for lhs, rhs in collector.assignments: 
            self._visit(rhs) 
        for lhs, rhs in collector.assignments: 
            self.mark_assignment(lhs, rhs) 
        return node 
 
    def visit_InPlaceAssignmentNode(self, node): 
        self.in_inplace_assignment = True 
        self.visitchildren(node) 
        self.in_inplace_assignment = False 
        self.mark_assignment(node.lhs, self.constant_folder(node.create_binop_node()))
        return node 
 
    def visit_DelStatNode(self, node): 
        for arg in node.args: 
            if arg.is_name: 
                entry = arg.entry or self.env.lookup(arg.name) 
                if entry.in_closure or entry.from_closure: 
                    error(arg.pos, 
                          "can not delete variable '%s' " 
                          "referenced in nested scope" % entry.name) 
                if not node.ignore_nonexisting:
                    self._visit(arg)  # mark reference
                self.flow.mark_deletion(arg, entry) 
            else: 
                self._visit(arg) 
        return node 
 
    def visit_CArgDeclNode(self, node): 
        entry = self.env.lookup(node.name) 
        if entry: 
            may_be_none = not node.not_none 
            self.flow.mark_argument( 
                node, TypedExprNode(entry.type, may_be_none), entry) 
        return node 
 
    def visit_NameNode(self, node): 
        if self.flow.block: 
            entry = node.entry or self.env.lookup(node.name) 
            if entry: 
                self.flow.mark_reference(node, entry) 
 
                if entry in self.reductions and not self.in_inplace_assignment: 
                    error(node.pos, 
                          "Cannot read reduction variable in loop body") 
 
        return node 
 
    def visit_StatListNode(self, node): 
        if self.flow.block: 
            for stat in node.stats: 
                self._visit(stat) 
                if not self.flow.block: 
                    stat.is_terminator = True 
                    break 
        return node 
 
    def visit_Node(self, node): 
        self.visitchildren(node) 
        self.mark_position(node) 
        return node 
 
    def visit_SizeofVarNode(self, node):
        return node

    def visit_TypeidNode(self, node):
        return node

    def visit_IfStatNode(self, node): 
        next_block = self.flow.newblock() 
        parent = self.flow.block 
        # If clauses 
        for clause in node.if_clauses: 
            parent = self.flow.nextblock(parent) 
            self._visit(clause.condition) 
            self.flow.nextblock() 
            self._visit(clause.body) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
        # Else clause 
        if node.else_clause: 
            self.flow.nextblock(parent=parent) 
            self._visit(node.else_clause) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
        else: 
            parent.add_child(next_block) 
 
        if next_block.parents: 
            self.flow.block = next_block 
        else: 
            self.flow.block = None 
        return node 
 
    def visit_WhileStatNode(self, node): 
        condition_block = self.flow.nextblock() 
        next_block = self.flow.newblock() 
        # Condition block 
        self.flow.loops.append(LoopDescr(next_block, condition_block)) 
        if node.condition: 
            self._visit(node.condition) 
        # Body block 
        self.flow.nextblock() 
        self._visit(node.body) 
        self.flow.loops.pop() 
        # Loop it 
        if self.flow.block: 
            self.flow.block.add_child(condition_block) 
            self.flow.block.add_child(next_block) 
        # Else clause 
        if node.else_clause: 
            self.flow.nextblock(parent=condition_block) 
            self._visit(node.else_clause) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
        else: 
            condition_block.add_child(next_block) 
 
        if next_block.parents: 
            self.flow.block = next_block 
        else: 
            self.flow.block = None 
        return node 
 
    def mark_forloop_target(self, node): 
        # TODO: Remove redundancy with range optimization... 
        is_special = False 
        sequence = node.iterator.sequence 
        target = node.target 
        if isinstance(sequence, ExprNodes.SimpleCallNode): 
            function = sequence.function 
            if sequence.self is None and function.is_name: 
                entry = self.env.lookup(function.name) 
                if not entry or entry.is_builtin: 
                    if function.name == 'reversed' and len(sequence.args) == 1: 
                        sequence = sequence.args[0] 
                    elif function.name == 'enumerate' and len(sequence.args) == 1: 
                        if target.is_sequence_constructor and len(target.args) == 2: 
                            iterator = sequence.args[0] 
                            if iterator.is_name: 
                                iterator_type = iterator.infer_type(self.env) 
                                if iterator_type.is_builtin_type: 
                                    # assume that builtin types have a length within Py_ssize_t 
                                    self.mark_assignment( 
                                        target.args[0], 
                                        ExprNodes.IntNode(target.pos, value='PY_SSIZE_T_MAX', 
                                                          type=PyrexTypes.c_py_ssize_t_type)) 
                                    target = target.args[1] 
                                    sequence = sequence.args[0] 
        if isinstance(sequence, ExprNodes.SimpleCallNode): 
            function = sequence.function 
            if sequence.self is None and function.is_name: 
                entry = self.env.lookup(function.name) 
                if not entry or entry.is_builtin: 
                    if function.name in ('range', 'xrange'): 
                        is_special = True 
                        for arg in sequence.args[:2]: 
                            self.mark_assignment(target, arg) 
                        if len(sequence.args) > 2: 
                            self.mark_assignment(target, self.constant_folder(
                                ExprNodes.binop_node(node.pos, 
                                                     '+', 
                                                     sequence.args[0], 
                                                     sequence.args[2])))
 
        if not is_special: 
            # A for-loop basically translates to subsequent calls to 
            # __getitem__(), so using an IndexNode here allows us to 
            # naturally infer the base type of pointers, C arrays, 
            # Python strings, etc., while correctly falling back to an 
            # object type when the base type cannot be handled. 
 
            self.mark_assignment(target, node.item) 
 
    def visit_AsyncForStatNode(self, node):
        return self.visit_ForInStatNode(node)

    def visit_ForInStatNode(self, node): 
        condition_block = self.flow.nextblock() 
        next_block = self.flow.newblock() 
        # Condition with iterator 
        self.flow.loops.append(LoopDescr(next_block, condition_block)) 
        self._visit(node.iterator) 
        # Target assignment 
        self.flow.nextblock() 
 
        if isinstance(node, Nodes.ForInStatNode): 
            self.mark_forloop_target(node) 
        elif isinstance(node, Nodes.AsyncForStatNode):
            # not entirely correct, but good enough for now
            self.mark_assignment(node.target, node.item)
        else: # Parallel 
            self.mark_assignment(node.target) 
 
        # Body block 
        if isinstance(node, Nodes.ParallelRangeNode): 
            # In case of an invalid 
            self._delete_privates(node, exclude=node.target.entry) 
 
        self.flow.nextblock() 
        self._visit(node.body) 
        self.flow.loops.pop() 
 
        # Loop it 
        if self.flow.block: 
            self.flow.block.add_child(condition_block) 
        # Else clause 
        if node.else_clause: 
            self.flow.nextblock(parent=condition_block) 
            self._visit(node.else_clause) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
        else: 
            condition_block.add_child(next_block) 
 
        if next_block.parents: 
            self.flow.block = next_block 
        else: 
            self.flow.block = None 
        return node 
 
    def _delete_privates(self, node, exclude=None): 
        for private_node in node.assigned_nodes: 
            if not exclude or private_node.entry is not exclude: 
                self.flow.mark_deletion(private_node, private_node.entry) 
 
    def visit_ParallelRangeNode(self, node): 
        reductions = self.reductions 
 
        # if node.target is None or not a NameNode, an error will have 
        # been previously issued 
        if hasattr(node.target, 'entry'): 
            self.reductions = set(reductions) 
 
            for private_node in node.assigned_nodes: 
                private_node.entry.error_on_uninitialized = True 
                pos, reduction = node.assignments[private_node.entry] 
                if reduction: 
                    self.reductions.add(private_node.entry) 
 
            node = self.visit_ForInStatNode(node) 
 
        self.reductions = reductions 
        return node 
 
    def visit_ParallelWithBlockNode(self, node): 
        for private_node in node.assigned_nodes: 
            private_node.entry.error_on_uninitialized = True 
 
        self._delete_privates(node) 
        self.visitchildren(node) 
        self._delete_privates(node) 
 
        return node 
 
    def visit_ForFromStatNode(self, node): 
        condition_block = self.flow.nextblock() 
        next_block = self.flow.newblock() 
        # Condition with iterator 
        self.flow.loops.append(LoopDescr(next_block, condition_block)) 
        self._visit(node.bound1) 
        self._visit(node.bound2) 
        if node.step is not None: 
            self._visit(node.step) 
        # Target assignment 
        self.flow.nextblock() 
        self.mark_assignment(node.target, node.bound1) 
        if node.step is not None: 
            self.mark_assignment(node.target, self.constant_folder(
                ExprNodes.binop_node(node.pos, '+', node.bound1, node.step)))
        # Body block 
        self.flow.nextblock() 
        self._visit(node.body) 
        self.flow.loops.pop() 
        # Loop it 
        if self.flow.block: 
            self.flow.block.add_child(condition_block) 
        # Else clause 
        if node.else_clause: 
            self.flow.nextblock(parent=condition_block) 
            self._visit(node.else_clause) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
        else: 
            condition_block.add_child(next_block) 
 
        if next_block.parents: 
            self.flow.block = next_block 
        else: 
            self.flow.block = None 
        return node 
 
    def visit_LoopNode(self, node): 
        raise InternalError("Generic loops are not supported") 
 
    def visit_WithTargetAssignmentStatNode(self, node): 
        self.mark_assignment(node.lhs, node.with_node.enter_call) 
        return node 
 
    def visit_WithStatNode(self, node): 
        self._visit(node.manager) 
        self._visit(node.enter_call) 
        self._visit(node.body) 
        return node 
 
    def visit_TryExceptStatNode(self, node): 
        # After exception handling 
        next_block = self.flow.newblock() 
        # Body block 
        self.flow.newblock() 
        # Exception entry point 
        entry_point = self.flow.newblock() 
        self.flow.exceptions.append(ExceptionDescr(entry_point)) 
        self.flow.nextblock() 
        ## XXX: links to exception handling point should be added by 
        ## XXX: children nodes 
        self.flow.block.add_child(entry_point) 
        self.flow.nextblock() 
        self._visit(node.body) 
        self.flow.exceptions.pop() 
 
        # After exception 
        if self.flow.block: 
            if node.else_clause: 
                self.flow.nextblock() 
                self._visit(node.else_clause) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
 
        for clause in node.except_clauses: 
            self.flow.block = entry_point 
            if clause.pattern: 
                for pattern in clause.pattern: 
                    self._visit(pattern) 
            else: 
                # TODO: handle * pattern 
                pass 
            entry_point = self.flow.newblock(parent=self.flow.block) 
            self.flow.nextblock() 
            if clause.target: 
                self.mark_assignment(clause.target) 
            self._visit(clause.body) 
            if self.flow.block: 
                self.flow.block.add_child(next_block) 
 
        if self.flow.exceptions: 
            entry_point.add_child(self.flow.exceptions[-1].entry_point) 
 
        if next_block.parents: 
            self.flow.block = next_block 
        else: 
            self.flow.block = None 
        return node 
 
    def visit_TryFinallyStatNode(self, node): 
        body_block = self.flow.nextblock() 
 
        # Exception entry point 
        entry_point = self.flow.newblock() 
        self.flow.block = entry_point 
        self._visit(node.finally_except_clause)
 
        if self.flow.block and self.flow.exceptions: 
            self.flow.block.add_child(self.flow.exceptions[-1].entry_point) 
 
        # Normal execution 
        finally_enter = self.flow.newblock() 
        self.flow.block = finally_enter 
        self._visit(node.finally_clause) 
        finally_exit = self.flow.block 
 
        descr = ExceptionDescr(entry_point, finally_enter, finally_exit) 
        self.flow.exceptions.append(descr) 
        if self.flow.loops: 
            self.flow.loops[-1].exceptions.append(descr) 
        self.flow.block = body_block 
        body_block.add_child(entry_point) 
        self.flow.nextblock() 
        self._visit(node.body) 
        self.flow.exceptions.pop() 
        if self.flow.loops: 
            self.flow.loops[-1].exceptions.pop() 
 
        if self.flow.block: 
            self.flow.block.add_child(finally_enter) 
            if finally_exit: 
                self.flow.block = self.flow.nextblock(parent=finally_exit) 
            else: 
                self.flow.block = None 
        return node 
 
    def visit_RaiseStatNode(self, node): 
        self.mark_position(node) 
        self.visitchildren(node) 
        if self.flow.exceptions: 
            self.flow.block.add_child(self.flow.exceptions[-1].entry_point) 
        self.flow.block = None 
        return node 
 
    def visit_ReraiseStatNode(self, node): 
        self.mark_position(node) 
        if self.flow.exceptions: 
            self.flow.block.add_child(self.flow.exceptions[-1].entry_point) 
        self.flow.block = None 
        return node 
 
    def visit_ReturnStatNode(self, node): 
        self.mark_position(node) 
        self.visitchildren(node) 
 
        outer_exception_handlers = iter(self.flow.exceptions[::-1])
        for handler in outer_exception_handlers:
            if handler.finally_enter:
                self.flow.block.add_child(handler.finally_enter)
                if handler.finally_exit:
                    # 'return' goes to function exit, or to the next outer 'finally' clause
                    exit_point = self.flow.exit_point
                    for next_handler in outer_exception_handlers:
                        if next_handler.finally_enter:
                            exit_point = next_handler.finally_enter
                            break
                    handler.finally_exit.add_child(exit_point)
                break 
        else: 
            if self.flow.block: 
                self.flow.block.add_child(self.flow.exit_point) 
        self.flow.block = None 
        return node 
 
    def visit_BreakStatNode(self, node): 
        if not self.flow.loops: 
            #error(node.pos, "break statement not inside loop") 
            return node 
        loop = self.flow.loops[-1] 
        self.mark_position(node) 
        for exception in loop.exceptions[::-1]: 
            if exception.finally_enter: 
                self.flow.block.add_child(exception.finally_enter) 
                if exception.finally_exit: 
                    exception.finally_exit.add_child(loop.next_block) 
                break 
        else: 
            self.flow.block.add_child(loop.next_block) 
        self.flow.block = None 
        return node 
 
    def visit_ContinueStatNode(self, node): 
        if not self.flow.loops: 
            #error(node.pos, "continue statement not inside loop") 
            return node 
        loop = self.flow.loops[-1] 
        self.mark_position(node) 
        for exception in loop.exceptions[::-1]: 
            if exception.finally_enter: 
                self.flow.block.add_child(exception.finally_enter) 
                if exception.finally_exit: 
                    exception.finally_exit.add_child(loop.loop_block) 
                break 
        else: 
            self.flow.block.add_child(loop.loop_block) 
        self.flow.block = None 
        return node 
 
    def visit_ComprehensionNode(self, node): 
        if node.expr_scope: 
            self.env_stack.append(self.env) 
            self.env = node.expr_scope 
        # Skip append node here 
        self._visit(node.loop) 
        if node.expr_scope: 
            self.env = self.env_stack.pop() 
        return node 
 
    def visit_ScopedExprNode(self, node): 
        if node.expr_scope: 
            self.env_stack.append(self.env) 
            self.env = node.expr_scope 
        self.visitchildren(node) 
        if node.expr_scope: 
            self.env = self.env_stack.pop() 
        return node 
 
    def visit_PyClassDefNode(self, node): 
        self.visitchildren(node, ('dict', 'metaclass', 
                                  'mkw', 'bases', 'class_result')) 
        self.flow.mark_assignment(node.target, node.classobj, 
                                  self.env.lookup(node.name)) 
        self.env_stack.append(self.env) 
        self.env = node.scope 
        self.flow.nextblock() 
        self.visitchildren(node, ('body',)) 
        self.flow.nextblock() 
        self.env = self.env_stack.pop() 
        return node 
 
    def visit_AmpersandNode(self, node): 
        if node.operand.is_name: 
            # Fake assignment to silence warning 
            self.mark_assignment(node.operand, fake_rhs_expr) 
        self.visitchildren(node) 
        return node