#!/usr/bin/env python  """ Inspect source files, obtaining details of classes and attributes.  Copyright (C) 2007, 2008, 2009, 2010, 2011 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  --------  The results of inspecting a module are as follows:  Constants ---------  All constants identified within the code shall be registered.  Classes -------  All global classes shall be registered; local classes (within functions) or nested classes (within classes) are not currently registered.  Base classes must be detected and constant.  All classes without bases are made to inherit from __builtins__.object in order to support some standard methods.  Functions ---------  All functions and lambda definitions shall be registered.  Namespaces ----------  Modules define their own "global" namespace, within which classes, functions and lambda definitions establish a hierarchy of namespaces.  Only local, global and built-in namespaces are recognised; closures are not supported.  Assignments -----------  Name assignment and attribute assignment involving modules and classes cause names to be associated with values within namespaces.  Any assignments within loops are considered to cause the targets of such assignments to provide non-constant values.  Assignments to names are only really considered to cause the targets of such assignments to provide constant values if the targets reside in the module namespace or in class namespaces, subject to the above conditions.  Assignments to names within functions are not generally considered to cause the targets of such assignments to provide constant values since functions can be invoked many times with different inputs. This affects particularly the definition of functions or lambdas within functions. However, there may be benefits in considering a local to be constant within a single invocation. """  from micropython.common import * from micropython.data import * import compiler.ast  # Program visitors.  class InspectedModule(ASTVisitor, Module):      """     An inspected module, providing core details via the Module superclass, but     capable of being used as an AST visitor.     """      def __init__(self, name, importer):          """         Initialise this visitor with a module 'name' and an 'importer' which is         used to provide access to other modules when required.         """          Module.__init__(self, name, importer)         self.visitor = self          # Import machinery links.          self.optimisations = self.importer.optimisations         self.builtins = self.importer.modules.get("__builtins__")         self.loaded = 0          # Current expression state.          self.expr = None         self.in_assignment = 0  # For slice and subscript handling.          # Namespace state.          self.in_method = 0      # Find instance attributes in all methods.         self.in_function = 0    # Note function presence, affecting definitions.         self.in_loop = 0        # Note loop "membership", affecting assignments.         self.namespaces = []         self.functions = []      def parse(self, filename):          "Parse the file having the given 'filename'."          module = compiler.parseFile(filename)         self.process(module)      def process(self, module):          "Process the given 'module'."          self.astnode = module          # Add __name__ to the namespace.          self.store("__name__", self._visitConst(self.full_name()))          # First, visit module-level code, recording global names.          processed = self.dispatch(module)          # Then, for each function, detect and record globals declared in those         # functions.           for node, namespaces in self.functions:             self.process_globals(node)          self.finalise_attribute_usage()          # Then, visit each function, recording other names.          for node, namespaces in self.functions:             self._visitFunctionBody(node, namespaces)             namespaces[-1].finalise_attribute_usage()          # Add references to other modules declared using the __all__ global.          if self.has_key("__all__"):             all = self["__all__"]             if isinstance(all, compiler.ast.List):                 for n in all.nodes:                     self.store(n.value, self.importer.add_module(self.name + "." + n.value))          return processed      def process_globals(self, node):          """         Within the given 'node', process global declarations, adjusting the         module namespace.         """          for n in node.getChildNodes():             if isinstance(n, compiler.ast.Global):                 for name in n.names:                     if not self.has_key(name):                         self[name] = make_instance()             else:                 self.process_globals(n)      def vacuum(self):          """         Vacuum the module namespace, removing unreferenced objects and unused         names.         """          if self.should_optimise_unused_objects():             self.vacuum_object(self)              all_objects = list(self.all_objects)              for obj in all_objects:                 self.vacuum_object(obj)      def vacuum_object(self, obj, delete_all=0):          "Vacuum the given object 'obj'."          # Get all constant objects in apparent use.          if delete_all:             obj_objects = set()         else:             obj_objects = []             for name, attr in obj.items_for_vacuum():                  # Get constant objects for attributes in use.                  if self.importer.uses_attribute(obj.full_name(), name) and \                     attr is not None and attr.is_constant():                      value = attr.get_value()                     obj_objects.append(value)          # Now vacuum unused attributes and objects not in use.          for name, attr in obj.items_for_vacuum():              # Only consider deleting entire unused objects or things accessible             # via names which are never used.              if delete_all or not self.importer.uses_attribute(obj.full_name(), name):                 obj.vacuum_item(name)                  # Delete any unambiguous attribute value. Such values can only                 # have been defined within the object and therefore are not                 # redefined by other code regions.                  if attr is not None and attr.is_constant():                     value = attr.get_value()                      # The value must have this object as a parent.                     # However, it must not be shared by several names.                      if value is not obj and value.parent is obj and \                         value in self.all_objects and value not in obj_objects:                          self.all_objects.remove(value)                          # Delete class contents and lambdas from functions.                          self.vacuum_object(value, 1)      def unfinalise(self):          "Reset finalised information for the module."          for obj in self.all_objects:             obj.unfinalise_attributes()      def finalise(self, objtable):          "Finalise the module."          for obj in self.all_objects:             obj.finalise(objtable)          self.finalise_users(objtable)      def add_object(self, obj, any_scope=0):          """         Record 'obj' if non-local or if the optional 'any_scope' is set to a         true value.         """          if any_scope or not (self.namespaces and isinstance(self.namespaces[-1], Function)):             self.all_objects.add(obj)      # Optimisation tests.      def should_optimise_unused_objects(self):         return "unused_objects" in self.optimisations      # Namespace methods.      def in_class(self, namespaces=None):         namespaces = namespaces or self.namespaces         return len(namespaces) > 1 and isinstance(namespaces[-2], Class)      def store(self, name, obj):          "Record attribute or local 'name', storing 'obj'."          # Store in the module.          if not self.namespaces:             if self.in_loop and self.used_in_scope(name, "builtins"):                 raise InspectError("Name %r already used as a built-in." % name)             else:                 self.set(name, obj, not self.in_loop)          # Or store locally.          else:             locals = self.namespaces[-1]              if self.in_loop and locals.used_in_scope(name, "global") and not name in locals.globals:                 raise InspectError("Name %r already used as global." % name)             elif self.in_loop and locals.used_in_scope(name, "builtins"):                 raise InspectError("Name %r already used as a built-in." % name)             else:                 locals.set(name, obj, not self.in_loop)      def store_lambda(self, obj):          "Store a lambda function 'obj'."          self.add_object(obj)         self.get_namespace().add_lambda(obj)      def store_module_attr(self, name, module):          """         Record module attribute 'name' in the given 'module' using the current         expression.         """          module.set(name, self.expr, 0)         self.use_specific_attribute(module.full_name(), name)      def store_class_attr(self, name, cls):          """         Record class attribute 'name' in the given class 'cls' using the current         expression.         """          cls.set(name, self.expr, 0)         self.use_specific_attribute(cls.full_name(), name)      def store_instance_attr(self, name):          "Record instance attribute 'name' in the current class."          if self.in_method:              # Current namespace is the function.             # Previous namespace is the class.              cls = self.namespaces[-2]             cls.add_instance_attribute(name)              # NOTE: The instance attribute, although defined in a specific             # NOTE: class, obviously appears in all descendant classes.              self.use_specific_attribute(cls.full_name(), name)      def get_namespace(self):          "Return the parent (or most recent) namespace currently exposed."          return (self.namespaces[-1:] or [self])[0]      def use_name(self, name, node=None, value=None):          """         Use the given 'name' within the current namespace/unit, either in         conjunction with a particular object (if 'node' is specified and not         None) or unconditionally.         """          if node is not None and isinstance(node, compiler.ast.Name):             self.use_attribute(node.name, name, value)          # For general name usage, declare usage of the given name from this         # particular unit.          else:             unit = self.get_namespace()             self.importer.use_name(name, unit.full_name(), value)      def use_constant(self, const):          "Use the given 'const' within the current namespace/unit."          unit = self.get_namespace()         self.importer.use_constant(const, unit.full_name())      # Attribute usage methods.     # These are convenience methods which refer to the specific namespace's     # implementation of these operations.      def new_branchpoint(self, loop_node=None):         self.get_namespace()._new_branchpoint(loop_node)      def new_branch(self, node):         self.get_namespace()._new_branch(node)      def abandon_branch(self):         self.get_namespace()._abandon_branch()      def suspend_broken_branch(self):         self.get_namespace()._suspend_broken_branch()      def suspend_continuing_branch(self):         self.get_namespace()._suspend_continuing_branch()      def shelve_branch(self):         self.get_namespace()._shelve_branch()      def merge_branches(self):         self.get_namespace()._merge_branches()      def resume_broken_branches(self):         self.get_namespace()._resume_broken_branches()      def resume_continuing_branches(self):         self.get_namespace()._resume_continuing_branches()      def define_attribute_user(self, node):          """         Define 'node' as the user of attributes, indicating the point where the         user is defined.         """          self.get_namespace()._define_attribute_user(node)      def use_attribute(self, name, attrname, value=None):          """         Note usage on the attribute user 'name' of the attribute 'attrname',         noting an assignment if 'value' is specified.         """          return self.get_namespace()._use_attribute(name, attrname, value)      def use_specific_attribute(self, objname, attrname, from_name=None):          """         Note usage on the object having the given 'objname' of the attribute         'attrname'. If 'objname' is None, the current namespace is chosen as the         object providing the attribute.         """          return self.get_namespace()._use_specific_attribute(objname, attrname, from_name)      # Visitor methods.      def default(self, node, *args):         raise InspectError("Node class %r is not supported." % node.__class__)      def NOP(self, node):         for n in node.getChildNodes():             self.dispatch(n)      def NOP_ABANDON(self, node):         self.NOP(node)         self.abandon_branch()      def TEST_NOP(self, node):         self.use_name("__bool__", node)         self.NOP(node)      def OP(self, node):         for n in node.getChildNodes():             self.dispatch(n)         return make_instance()      def TEST_OP(self, node):         self.use_name("__bool__", node)         return self.OP(node)      # Generic support for classes of operations.      def _ensureOperators(self):         attr, scope, namespace = self._get_with_scope("$operator")         if attr is None:             module = self.importer.load("operator")             self["$operator"] = module         else:             module = attr.get_value()         return module      def _visitOperator(self, node, operator_name=None):          "Accounting method for the operator 'node'."          operator_module = self._ensureOperators()         operator_fn = operator_functions[operator_name or node.__class__.__name__]         self.use_specific_attribute(operator_module.full_name(), operator_fn)         return self.OP(node)      _visitBinary = _visitOperator     _visitUnary = _visitOperator      def _visitAttr(self, expr, attrname, node):          """         Process the attribute provided by the given 'expr' with the given         'attrname' and involving the given 'node'.         """          # Attempt to identify the nature of the attribute.          if isinstance(expr, Attr):             value = expr.get_value()              # Get the attribute and record its usage.              if isinstance(value, (Class, Module)):                  # Check for class.__class__.                  if attrname == "__class__" and isinstance(value, Class):                     attr = type_class                 else:                     attr = value.get(attrname) or make_instance()                 self.use_specific_attribute(value.full_name(), attrname)              elif isinstance(value, UnresolvedName):                 attr = UnresolvedName(attrname, value.full_name(), self)              # The actual attribute is not readily identifiable and is assumed             # to be an instance.              else:                 attr = make_instance()                  # Note usage of the attribute where a local is involved.                  self._visitAttrUser(expr, attrname, node)          # No particular attribute has been identified, thus a general instance         # is assumed.          else:             attr = make_instance()             self.use_name(attrname, node)          return attr      def _visitAttrUser(self, expr, attrname, node, value=None):          """         Note usage of the attribute provided by 'expr' with the given 'attrname'         where a local is involved, annotating the given 'node'. If the optional         'value' is given, note an assignment for future effects on attributes         where such attributes are inferred from the usage.         """          # Access to attribute via a local.          if expr.parent is self.get_namespace():              # NOTE: Revisiting of nodes may occur for loops.              if not hasattr(node, "_attrusers"):                 node._attrusers = set()              node._attrusers.update(self.use_attribute(expr.name, attrname, value))             node._username = expr.name         else:             self.use_name(attrname, node.expr, value)      def _visitConst(self, value):          """         Register the constant given by 'value', if necessary, returning the         resulting object. The type name is noted as being used, thus preserving         the class in any generated program.         """          self.use_specific_attribute("__builtins__", self.importer.get_constant_type_name(value))         const = self.importer.make_constant(value)         self.use_constant(const)         return const      def _visitFunction(self, node, name):          """         Return a function object for the function defined by 'node' with the         given 'name'. If a lambda expression is being visited, 'name' should be         None.         """          # Define the function object.          function = Function(             name,             self.get_namespace(),             node.argnames,             node.defaults,             (node.flags & 4 != 0),             (node.flags & 8 != 0),             self.in_loop or self.in_function,             self,             node             )          self.add_object(function, any_scope=1)          # Make a back reference from the node for code generation.          node.unit = function          # Process the defaults.          for n in node.defaults:             self.expr = self.dispatch(n)             function.store_default(self.expr)          # Note attribute usage where tuple parameters are involved.          if function.tuple_parameters():             self.use_name("__getitem__", node)          # Record the namespace context of the function for later processing.          self.functions.append((node, self.namespaces + [function]))          # Store the function.          if name is not None:             self.store(name, function)         else:             self.store_lambda(function)          # Test the defaults and assess whether an dynamic object will result.          function.make_dynamic()         return function      def _visitFunctionBody(self, node, namespaces):          "Enter the function."          # Current namespace is the function.         # Previous namespace is the class.          if self.in_class(namespaces):             self.in_method = 1          in_function = self.in_function         in_loop = self.in_loop         self.in_function = 1         self.in_loop = 0          self.namespaces = namespaces         self.dispatch(node.code)          self.in_loop = in_loop         self.in_function = in_function         self.in_method = 0      # Specific handler methods.      visitAdd = _visitBinary      visitAnd = TEST_OP      visitAssert = NOP      def visitAssign(self, node):         self.expr = self.dispatch(node.expr)         self.in_assignment = 1         for n in node.nodes:             self.dispatch(n)         self.in_assignment = 0      def visitAssAttr(self, node):         expr = self.dispatch(node.expr)         attrname = node.attrname          # Record the attribute on the presumed target.          if isinstance(expr, Attr):             value = expr.get_value()              if expr.name == "self":                 self.store_instance_attr(attrname)                 self.use_attribute(expr.name, attrname, value) # NOTE: Impose constraints on the type given the hierarchy.                 self._visitAttrUser(expr, attrname, node, self.expr)              elif isinstance(value, Module):                 self.store_module_attr(attrname, value)                 print "Warning: attribute %r of module %r set outside the module." % (node.attrname, expr.get_value().name)              elif isinstance(value, Class):                 self.store_class_attr(attrname, value)              # Note usage of the attribute where a local is involved.              else:                 self._visitAttrUser(expr, attrname, node, self.expr)          else:             self.use_name(attrname, node)      def visitAssList(self, node):          # Declare names which will be used by generated code.          self.use_name("__getitem__", node)          # Process the assignment.          for i, n in enumerate(node.nodes):             self.dispatch(n)             self._visitConst(i) # for __getitem__(i) at run-time      def visitAssName(self, node):         if hasattr(node, "flags") and node.flags == "OP_DELETE":             print "Warning: deletion of attribute %r in %r is not supported." % (node.name, self.full_name())             #raise InspectError("Deletion of attribute %r is not supported." % node.name)          self.store(node.name, self.expr)         self.define_attribute_user(node)          # Ensure the presence of the given name in this namespace.         # NOTE: Consider not registering assignments involving methods, since         # NOTE: this is merely creating aliases for such methods.          if isinstance(self.get_namespace(), (Class, Module)):             if not isinstance(self.expr, Attr) or not isinstance(self.expr.get_value(), Function):                 self.use_specific_attribute(None, node.name)             else:                 fn = self.expr.get_value()                 ns = self.get_namespace().full_name()                 self.use_specific_attribute(fn.parent.full_name(), fn.name, "%s.%s" % (ns, node.name))      visitAssTuple = visitAssList      def visitAugAssign(self, node):          # Accounting.          operator_fn = operator_functions.get(node.op)         operator_module = self._ensureOperators()         self.use_specific_attribute(operator_module.full_name(), operator_fn)          # Process the assignment.          self.expr = self.dispatch(node.expr)          # NOTE: Similar to micropython.ast handler code.         # NOTE: Slices and subscripts are supported by __setitem__(slice) and         # NOTE: not __setslice__.          if isinstance(node.node, compiler.ast.Name):             self.visitAssName(node.node)         elif isinstance(node.node, compiler.ast.Getattr):             self.visitAssAttr(node.node)         else:             self.use_specific_attribute("__builtins__", "slice")             self.use_name("__setitem__", node)      visitBackquote = OP      visitBitand = _visitBinary      visitBitor = _visitBinary      visitBitxor = _visitBinary      def visitBreak(self, node):         self.NOP(node)         self.suspend_broken_branch()      visitCallFunc = OP      def visitClass(self, node):          """         Register the class at the given 'node' subject to the restrictions         mentioned in the module docstring.         """          if self.namespaces:             print "Warning: class %r in %r is not global: ignored." % (node.name, self.namespaces[-1].full_name())             return         else:             if self.in_loop:                 print "Warning: class %r in %r defined in a loop." % (node.name, self.full_name())              cls = get_class(node.name, self.get_namespace(), self, node)              # Make a back reference from the node for code generation.              node.unit = cls              # Process base classes in the context of the class's namespace.             # This confines references to such classes to the class instead of             # the namespace in which it is defined.              self.namespaces.append(cls)              # Visit the base class expressions, attempting to find concrete             # definitions of classes.              for base in node.bases:                 expr = self.dispatch(base)                  # Each base class must be constant and known at compile-time.                  if isinstance(expr, Attr):                     if expr.assignments != 1:                         raise InspectError("Base class %r for %r is not constant: %r" % (base, cls.full_name(), expr))                     else:                         cls.add_base(expr.get_value())                  # Where no expression value is available, the base class is                 # not identifiable.                  else:                     raise InspectError("Base class %r for %r is not found: it may be hidden in some way." % (base, cls.full_name()))              # NOTE: Potentially dubious measure to permit __init__ availability.             # If no bases exist, adopt the 'object' class.              if not node.bases and not (self.name == "__builtins__" and node.name == "object") :                 expr = self.dispatch(compiler.ast.Name("object"))                 cls.add_base(expr.get_value())              # Make an entry for the class in the parent namespace.              self.namespaces.pop()             self.store(node.name, cls)             self.add_object(cls)              # Process the class body in its own namespace.             # Add __name__ to the namespace.              self.namespaces.append(cls)             self.store("__name__", self._visitConst(node.name))             self.dispatch(node.code)             self.namespaces.pop()              cls.finalise_attribute_usage()             return cls      def visitCompare(self, node):          # Accounting.         # NOTE: Replicates some code in micropython.ast.visitCompare.          self.use_name("__bool__", node)          this_node = node          for op in node.ops:             op_name, next_node = op              # Define name/attribute usage.             # Get the applicable operation.              operator_fn = operator_functions.get(op_name)              # For operators, reference the specific function involved.              if operator_fn is not None:                 operator_module = self._ensureOperators()                 self.use_specific_attribute(operator_module.full_name(), operator_fn)              # Define __contains__ usage on the next node.              elif op_name.endswith("in"):                 self.use_name("__contains__", next_node)              this_node = next_node          return self.OP(node)      def visitConst(self, node):         return self._visitConst(node.value)      def visitContinue(self, node):         self.NOP(node)         self.suspend_continuing_branch()      visitDecorators = NOP      visitDict = OP      visitDiscard = NOP      visitDiv = _visitBinary      visitEllipsis = NOP      visitExec = NOP      visitExpression = OP      visitFloorDiv = _visitBinary      def visitFor(self, node):         self.new_branchpoint(node)          # Declare names which will be used by generated code.          self.use_name("__iter__", node.list)         self.use_name("next")         self.use_name("StopIteration")          in_loop = self.in_loop         self.in_loop = 1         self.dispatch(node.list)          # NOTE: Could generate AST nodes for the actual operations instead of         # NOTE: manually generating code in micropython.ast.          self.expr = make_instance() # each element is a result of a function call         self.dispatch(node.assign)          # Enter the loop.         # Propagate attribute usage to branches.          self.new_branch(node)         self.dispatch(node.body)          self.resume_continuing_branches()          self.shelve_branch()          self.in_loop = in_loop          # A null branch is used to record a path around the loop.          self.new_branch(node.else_ or NullBranch())         self.shelve_branch()          self.merge_branches()          # The else clause is evaluated outside any branch.          if node.else_ is not None:             self.dispatch(node.else_)          # Any suspended branches from the loop can now be resumed.          self.resume_broken_branches()      def visitFrom(self, node):         module = self.importer.load(node.modname, 1)          #if module is None:         #    print "Warning:", node.modname, "not imported."          for name, alias in node.names:             if name != "*":                 if module is not None:                      # Missing names may refer to submodules.                      if not module.has_key(name):                         submodule = self.importer.load(node.modname + "." + name, 1)                         if submodule is not None:                             module.store(name, submodule)                      # Complete the import if the name was found.                      if module.has_key(name):                         attr = module[name]                         self.store(alias or name, attr)                         self.use_specific_attribute(module.full_name(), name)                         if isinstance(attr.get_value(), Module) and not attr.get_value().loaded:                             self.importer.load(attr.get_value().name)                         continue                  # Support the import of names from missing modules.                  self.store(alias or name, UnresolvedName(name, node.modname, self))              else:                 if module is not None:                     for n in module.keys():                         attr = module[n]                         self.store(n, attr)                         self.use_specific_attribute(module.full_name(), n)                         if isinstance(attr.get_value(), Module) and not attr.get_value().loaded:                             self.importer.load(attr.get_value().name)      def visitFunction(self, node):         return self._visitFunction(node, node.name)      visitGenExpr = OP      visitGenExprFor = NOP      visitGenExprIf = NOP      visitGenExprInner = NOP      def visitGetattr(self, node):         expr = self.dispatch(node.expr)         attrname = node.attrname         return self._visitAttr(expr, attrname, node)      def visitGlobal(self, node):         if self.namespaces:             for name in node.names:                 ns = self.namespaces[-1]                 if not ns.make_global(name):                     raise InspectError("Name %r is global and local in %r" % (name, ns.full_name()))                  # The name is recorded in an earlier process.      def visitIf(self, node):         self.use_name("__bool__", node)         self.new_branchpoint()          # Propagate attribute usage to branches.          for test, body in node.tests:             self.dispatch(test)              self.new_branch(body)             self.dispatch(body)             self.shelve_branch()          # Maintain a branch for the else clause.          self.new_branch(node.else_ or NullBranch())         if node.else_ is not None:             self.dispatch(node.else_)         self.shelve_branch()          self.merge_branches()      def visitIfExp(self, node):         self.use_name("__bool__", node)         self.new_branchpoint()          # Propagate attribute usage to branches.          self.dispatch(node.test)          self.new_branch(node.then)         self.dispatch(node.then)         self.shelve_branch()          self.new_branch(node.else_)         self.dispatch(node.else_)         self.shelve_branch()          self.merge_branches()         return make_instance() # either outcome is possible      def visitImport(self, node):         for name, alias in node.names:             if alias is not None:                 module = self.importer.load(name, 1) or UnresolvedName(None, name, self)                 self.store(alias, module)             else:                 module = self.importer.load(name) or UnresolvedName(None, name.split(".")[0], self)                 self.store(name.split(".")[0], module)      visitInvert = _visitUnary      def visitKeyword(self, node):         self.dispatch(node.expr)         self._visitConst(node.name)         self.keyword_names.add(node.name)      def visitLambda(self, node):         fn = self._visitFunction(node, None)         self.use_specific_attribute(None, fn.name)         return fn      visitLeftShift = _visitBinary      def visitList(self, node):         self.use_specific_attribute("__builtins__", "list")         return self.OP(node)      def visitListComp(self, node):         for qual in node.quals:             self.dispatch(qual)         self.dispatch(node.expr)         return make_instance()      def visitListCompFor(self, node):         self.new_branchpoint()          # Declare names which will be used by generated code.          self.use_name("__iter__", node.list)         self.use_name("next")          in_loop = self.in_loop         self.in_loop = 1         self.dispatch(node.list)          # NOTE: Could generate AST nodes for the actual operations instead of         # NOTE: manually generating code in micropython.ast.          self.expr = make_instance() # each element is a result of a function call         self.dispatch(node.assign)          # Enter the loop.         # Propagate attribute usage to branches.          self.new_branch(node)          for if_ in node.ifs:             self.dispatch(if_)          self.shelve_branch()         self.in_loop = in_loop          self.merge_branches()      visitListCompIf = TEST_NOP      visitMod = _visitBinary      def visitModule(self, node):          # Make a back reference from the node for code generation.          node.unit = self         return self.dispatch(node.node)      visitMul = _visitBinary      def visitName(self, node):         return self.get_namespace().get_using_node(node.name, node) or make_instance()      visitNot = TEST_OP      visitOr = TEST_OP      visitPass = NOP      visitPower = _visitBinary      def _visitPrint(self, node, function_name):         self.NOP(node)         self.use_specific_attribute("__builtins__", function_name)      def visitPrint(self, node):         self._visitPrint(node, "_print")      def visitPrintnl(self, node):         self._visitPrint(node, "_printnl")      visitRaise = NOP_ABANDON      visitReturn = NOP_ABANDON      visitRightShift = _visitBinary      def visitSlice(self, node):         return self._visitOperator(node, self.in_assignment and "AssSlice" or "Slice")      visitSliceobj = OP      def visitStmt(self, node):         for n in node.nodes:             self.dispatch(n)      visitSub = _visitBinary      def visitSubscript(self, node):         return self._visitOperator(node, self.in_assignment and "AssSubscript" or "Subscript")      def visitTryExcept(self, node):         self.dispatch(node.body)          self.new_branchpoint()          for name, var, n in node.handlers:             self.new_branch(node)              # Establish the local for the handler.              if var is not None:                 self.dispatch(var)             if n is not None:                 self.dispatch(n)              self.shelve_branch()          self.new_branch(node.else_ or NullBranch())         if node.else_ is not None:             self.dispatch(node.else_)         self.shelve_branch()          self.merge_branches()      visitTryFinally = NOP      visitTuple = OP      visitUnaryAdd = _visitUnary      visitUnarySub = _visitUnary      def visitWhile(self, node):         self.use_name("__bool__", node)         self.new_branchpoint(node)          # Propagate attribute usage to branches.          in_loop = self.in_loop         self.in_loop = 1          # The test is evaluated initially and again in the loop.          self.dispatch(node.test)          self.new_branch(node)         self.dispatch(node.body)          self.resume_continuing_branches()          self.dispatch(node.test)         self.shelve_branch()          self.in_loop = in_loop          # A null branch is used to record a path around the loop.          self.new_branch(node.else_ or NullBranch())         self.shelve_branch()          self.merge_branches()          # The else clause is evaluated outside any branch.          if node.else_ is not None:             self.dispatch(node.else_)          # Any suspended branches from the loop can now be resumed.          self.resume_broken_branches()      visitWith = NOP      visitYield = NOP  # vim: tabstop=4 expandtab shiftwidth=4