Lichen

Annotated inspector.py

979:2957d8a7ccfb
1031:aa1826243f0c
938:799711337453
5 months ago Paul Boddie file changeset files shortlog Avoid creating zero-length temporary arrays.
paul@0 1 
#!/usr/bin/env python
paul@0 2 
 
 paul@0      3 
"""
 
 paul@0      4 
Inspect and obtain module structure.
 
 paul@0      5 
 
 paul@938      6 
Copyright (C) 2007-2019, 2021 Paul Boddie <paul@boddie.org.uk>
 
 paul@0      7 
 
 paul@0      8 
This program is free software; you can redistribute it and/or modify it under
 
 paul@0      9 
the terms of the GNU General Public License as published by the Free Software
 
 paul@0     10 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@0     11 
version.
 
 paul@0     12 
 
 paul@0     13 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@0     14 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@0     15 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@0     16 
details.
 
 paul@0     17 
 
 paul@0     18 
You should have received a copy of the GNU General Public License along with
 
 paul@0     19 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@0     20 
"""
 
 paul@0     21 
 
 paul@0     22 
from branching import BranchTracker
 
 paul@845     23 
from common import CommonModule, get_argnames, init_item, \
 
 paul@845     24 
                   predefined_constants, privileged_attributes
 
 paul@26     25 
from modules import BasicModule, CacheWritingModule, InspectionNaming
 
 paul@3     26 
from errors import InspectError
 
 paul@0     27 
from referencing import Reference
 
 paul@12     28 
from resolving import NameResolving
 
 paul@12     29 
from results import AccessRef, InstanceRef, InvocationRef, LiteralSequenceRef, \
 
 paul@794     30 
                    LocalNameRef, MultipleRef, NameRef, ResolvedNameRef, \
 
 paul@794     31 
                    Result, VariableRef
 
 paul@0     32 
import compiler
 
 paul@0     33 
import sys
 
 paul@0     34 
 
 paul@26     35 
class InspectedModule(BasicModule, CacheWritingModule, NameResolving, InspectionNaming):
 
 paul@0     36 
 
 paul@0     37 
    "A module inspector."
 
 paul@0     38 
 
 paul@0     39 
    def __init__(self, name, importer):
 
 paul@13     40 
 
 paul@13     41 
        "Initialise the module with basic details."
 
 paul@13     42 
 
 paul@0     43 
        BasicModule.__init__(self, name, importer)
 
 paul@12     44 
 
 paul@0     45 
        self.in_class = False
 
 paul@0     46 
        self.in_conditional = False
 
 paul@110     47 
 
 paul@110     48 
        # Accesses to global attributes.
 
 paul@110     49 
 
 paul@0     50 
        self.global_attr_accesses = {}
 
 paul@0     51 
 
 paul@0     52 
        # Usage tracking.
 
 paul@0     53 
 
 paul@0     54 
        self.trackers = []
 
 paul@0     55 
        self.attr_accessor_branches = {}
 
 paul@0     56 
 
 paul@0     57 
    def __repr__(self):
 
 paul@0     58 
        return "InspectedModule(%r, %r)" % (self.name, self.importer)
 
 paul@0     59 
 
 paul@27     60 
    # Principal methods.
 
 paul@27     61 
 
 paul@0     62 
    def parse(self, filename):
 
 paul@0     63 
 
 paul@0     64 
        "Parse the file having the given 'filename'."
 
 paul@0     65 
 
 paul@0     66 
        self.parse_file(filename)
 
 paul@0     67 
 
 paul@0     68 
        # Inspect the module.
 
 paul@0     69 
 
 paul@0     70 
        self.start_tracking_in_module()
 
 paul@0     71 
 
 paul@0     72 
        # Detect and record imports and globals declared in the module.
 
 paul@0     73 
 
 paul@0     74 
        self.process_structure(self.astnode)
 
 paul@0     75 
 
 paul@0     76 
        # Set the class of the module after the definition has occurred.
 
 paul@0     77 
 
 paul@269     78 
        ref = self.get_builtin("module")
 
 paul@0     79 
        self.set_name("__class__", ref)
 
 paul@938     80 
        self.set_name("__name__", self.get_constant("str", self.name).reference())
 
 paul@938     81 
        self.set_name("__file__", self.get_constant("str", filename).reference())
 
 paul@0     82 
 
 paul@406     83 
        # Reserve a constant for the encoding.
 
 paul@406     84 
 
 paul@406     85 
        if self.encoding:
 
 paul@938     86 
            self.get_constant("str", self.encoding)
 
 paul@406     87 
 
 paul@0     88 
        # Get module-level attribute usage details.
 
 paul@0     89 
 
 paul@0     90 
        self.stop_tracking_in_module()
 
 paul@0     91 
 
 paul@27     92 
        # Collect external name references.
 
 paul@0     93 
 
 paul@27     94 
        self.collect_names()
 
 paul@0     95 
 
 paul@12     96 
    def complete(self):
 
 paul@0     97 
 
 paul@12     98 
        "Complete the module inspection."
 
 paul@0     99 
 
 paul@12    100 
        # Resolve names not definitively mapped to objects.
 
 paul@0    101 
 
 paul@12    102 
        self.resolve()
 
 paul@0    103 
 
 paul@12    104 
        # Propagate to the importer information needed in subsequent activities.
 
 paul@0    105 
 
 paul@12    106 
        self.propagate()
 
 paul@0    107 
 
 paul@27    108 
    # Accessory methods.
 
 paul@0    109 
 
 paul@27    110 
    def collect_names(self):
 
 paul@0    111 
 
 paul@27    112 
        "Collect the names used by each scope."
 
 paul@0    113 
 
 paul@0    114 
        for path in self.names_used.keys():
 
 paul@27    115 
            self.collect_names_for_path(path)
 
 paul@27    116 
 
 paul@27    117 
    def collect_names_for_path(self, path):
 
 paul@0    118 
 
 paul@33    119 
        """
 
 paul@33    120 
        Collect the names used by the given 'path'. These are propagated to the
 
 paul@33    121 
        importer in advance of any dependency resolution.
 
 paul@33    122 
        """
 
 paul@0    123 
 
 paul@0    124 
        names = self.names_used.get(path)
 
 paul@0    125 
        if not names:
 
 paul@0    126 
            return
 
 paul@0    127 
 
 paul@0    128 
        in_function = self.function_locals.has_key(path)
 
 paul@0    129 
 
 paul@0    130 
        for name in names:
 
 paul@135    131 
            if in_function and name in self.function_locals[path]:
 
 paul@135    132 
                continue
 
 paul@135    133 
 
 paul@135    134 
            key = "%s.%s" % (path, name)
 
 paul@135    135 
 
 paul@792    136 
            # Find local definitions.
 
 paul@0    137 
 
 paul@792    138 
            ref = self.get_resolved_object(key, True)
 
 paul@0    139 
            if ref:
 
 paul@40    140 
                self.set_name_reference(key, ref)
 
 paul@0    141 
                continue
 
 paul@0    142 
 
 paul@142    143 
            # Find global.
 
 paul@0    144 
 
 paul@142    145 
            ref = self.get_global(name)
 
 paul@27    146 
            if ref:
 
 paul@40    147 
                self.set_name_reference(key, ref)
 
 paul@0    148 
                continue
 
 paul@0    149 
 
 paul@40    150 
            # Find presumed built-in definitions.
 
 paul@0    151 
 
 paul@40    152 
            ref = self.get_builtin(name)
 
 paul@40    153 
            self.set_name_reference(key, ref)
 
 paul@0    154 
 
 paul@40    155 
    def set_name_reference(self, path, ref):
 
 paul@0    156 
 
 paul@40    157 
        "Map the given name 'path' to 'ref'."
 
 paul@0    158 
 
 paul@40    159 
        self.importer.all_name_references[path] = self.name_references[path] = ref
 
 paul@0    160 
 
 paul@0    161 
    # Module structure traversal.
 
 paul@0    162 
 
 paul@0    163 
    def process_structure_node(self, n):
 
 paul@0    164 
 
 paul@0    165 
        "Process the individual node 'n'."
 
 paul@0    166 
 
 paul@205    167 
        path = self.get_namespace_path()
 
 paul@205    168 
 
 paul@0    169 
        # Module global detection.
 
 paul@0    170 
 
 paul@0    171 
        if isinstance(n, compiler.ast.Global):
 
 paul@0    172 
            self.process_global_node(n)
 
 paul@0    173 
 
 paul@0    174 
        # Module import declarations.
 
 paul@0    175 
 
 paul@0    176 
        elif isinstance(n, compiler.ast.From):
 
 paul@0    177 
            self.process_from_node(n)
 
 paul@0    178 
 
 paul@0    179 
        elif isinstance(n, compiler.ast.Import):
 
 paul@0    180 
            self.process_import_node(n)
 
 paul@0    181 
 
 paul@0    182 
        # Nodes using operator module functions.
 
 paul@0    183 
 
 paul@0    184 
        elif isinstance(n, compiler.ast.Operator):
 
 paul@0    185 
            return self.process_operator_node(n)
 
 paul@0    186 
 
 paul@0    187 
        elif isinstance(n, compiler.ast.AugAssign):
 
 paul@0    188 
            self.process_augassign_node(n)
 
 paul@0    189 
 
 paul@0    190 
        elif isinstance(n, compiler.ast.Compare):
 
 paul@0    191 
            return self.process_compare_node(n)
 
 paul@0    192 
 
 paul@0    193 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@0    194 
            return self.process_slice_node(n)
 
 paul@0    195 
 
 paul@0    196 
        elif isinstance(n, compiler.ast.Sliceobj):
 
 paul@0    197 
            return self.process_sliceobj_node(n)
 
 paul@0    198 
 
 paul@0    199 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@0    200 
            return self.process_subscript_node(n)
 
 paul@0    201 
 
 paul@0    202 
        # Namespaces within modules.
 
 paul@0    203 
 
 paul@0    204 
        elif isinstance(n, compiler.ast.Class):
 
 paul@0    205 
            self.process_class_node(n)
 
 paul@0    206 
 
 paul@0    207 
        elif isinstance(n, compiler.ast.Function):
 
 paul@0    208 
            self.process_function_node(n, n.name)
 
 paul@0    209 
 
 paul@0    210 
        elif isinstance(n, compiler.ast.Lambda):
 
 paul@0    211 
            return self.process_lambda_node(n)
 
 paul@0    212 
 
 paul@0    213 
        # Assignments.
 
 paul@0    214 
 
 paul@0    215 
        elif isinstance(n, compiler.ast.Assign):
 
 paul@0    216 
 
 paul@0    217 
            # Handle each assignment node.
 
 paul@0    218 
 
 paul@0    219 
            for node in n.nodes:
 
 paul@0    220 
                self.process_assignment_node(node, n.expr)
 
 paul@0    221 
 
 paul@0    222 
        # Assignments within non-Assign nodes.
 
 paul@0    223 
 
 paul@0    224 
        elif isinstance(n, compiler.ast.AssName):
 
 paul@205    225 
            raise InspectError("Name assignment appearing outside assignment statement.", path, n)
 
 paul@0    226 
 
 paul@0    227 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@205    228 
            raise InspectError("Attribute assignment appearing outside assignment statement.", path, n)
 
 paul@0    229 
 
 paul@0    230 
        # Accesses.
 
 paul@0    231 
 
 paul@0    232 
        elif isinstance(n, compiler.ast.Getattr):
 
 paul@0    233 
            return self.process_attribute_access(n)
 
 paul@0    234 
 
 paul@0    235 
        # Name recording for later testing.
 
 paul@0    236 
 
 paul@0    237 
        elif isinstance(n, compiler.ast.Name):
 
 paul@0    238 
            return self.process_name_node(n)
 
 paul@0    239 
 
 paul@0    240 
        # Conditional statement tracking.
 
 paul@0    241 
 
 paul@0    242 
        elif isinstance(n, compiler.ast.For):
 
 paul@0    243 
            self.process_for_node(n)
 
 paul@0    244 
 
 paul@0    245 
        elif isinstance(n, compiler.ast.While):
 
 paul@0    246 
            self.process_while_node(n)
 
 paul@0    247 
 
 paul@0    248 
        elif isinstance(n, compiler.ast.If):
 
 paul@0    249 
            self.process_if_node(n)
 
 paul@0    250 
 
 paul@0    251 
        elif isinstance(n, (compiler.ast.And, compiler.ast.Or)):
 
 paul@0    252 
            return self.process_logical_node(n)
 
 paul@0    253 
 
 paul@0    254 
        # Exception control-flow tracking.
 
 paul@0    255 
 
 paul@0    256 
        elif isinstance(n, compiler.ast.TryExcept):
 
 paul@0    257 
            self.process_try_node(n)
 
 paul@0    258 
 
 paul@0    259 
        elif isinstance(n, compiler.ast.TryFinally):
 
 paul@0    260 
            self.process_try_finally_node(n)
 
 paul@0    261 
 
 paul@0    262 
        # Control-flow modification statements.
 
 paul@0    263 
 
 paul@0    264 
        elif isinstance(n, compiler.ast.Break):
 
 paul@0    265 
            self.trackers[-1].suspend_broken_branch()
 
 paul@0    266 
 
 paul@0    267 
        elif isinstance(n, compiler.ast.Continue):
 
 paul@0    268 
            self.trackers[-1].suspend_continuing_branch()
 
 paul@0    269 
 
 paul@0    270 
        elif isinstance(n, compiler.ast.Raise):
 
 paul@0    271 
            self.process_structure(n)
 
 paul@0    272 
            self.trackers[-1].abandon_branch()
 
 paul@0    273 
 
 paul@0    274 
        elif isinstance(n, compiler.ast.Return):
 
 paul@703    275 
            self.record_return_value(self.process_structure_node(n.value))
 
 paul@0    276 
            self.trackers[-1].abandon_returning_branch()
 
 paul@0    277 
 
 paul@173    278 
        # Print statements.
 
 paul@173    279 
 
 paul@173    280 
        elif isinstance(n, (compiler.ast.Print, compiler.ast.Printnl)):
 
 paul@173    281 
            self.process_print_node(n)
 
 paul@173    282 
 
 paul@0    283 
        # Invocations.
 
 paul@0    284 
 
 paul@0    285 
        elif isinstance(n, compiler.ast.CallFunc):
 
 paul@0    286 
            return self.process_invocation_node(n)
 
 paul@0    287 
 
 paul@0    288 
        # Constant usage.
 
 paul@0    289 
 
 paul@0    290 
        elif isinstance(n, compiler.ast.Const):
 
 paul@405    291 
            return self.get_literal_instance(n)
 
 paul@0    292 
 
 paul@0    293 
        elif isinstance(n, compiler.ast.Dict):
 
 paul@0    294 
            return self.get_literal_instance(n, "dict")
 
 paul@0    295 
 
 paul@0    296 
        elif isinstance(n, compiler.ast.List):
 
 paul@0    297 
            return self.get_literal_instance(n, "list")
 
 paul@0    298 
 
 paul@0    299 
        elif isinstance(n, compiler.ast.Tuple):
 
 paul@0    300 
            return self.get_literal_instance(n, "tuple")
 
 paul@0    301 
 
 paul@0    302 
        # All other nodes are processed depth-first.
 
 paul@0    303 
 
 paul@0    304 
        else:
 
 paul@0    305 
            self.process_structure(n)
 
 paul@0    306 
 
 paul@0    307 
        # By default, no expression details are returned.
 
 paul@0    308 
 
 paul@0    309 
        return None
 
 paul@0    310 
 
 paul@0    311 
    # Specific node handling.
 
 paul@0    312 
 
 paul@0    313 
    def process_assignment_node(self, n, expr):
 
 paul@0    314 
 
 paul@0    315 
        "Process the individual node 'n' to be assigned the contents of 'expr'."
 
 paul@0    316 
 
 paul@0    317 
        # Names and attributes are assigned the entire expression.
 
 paul@0    318 
 
 paul@0    319 
        if isinstance(n, compiler.ast.AssName):
 
 paul@61    320 
            if n.name == "self":
 
 paul@61    321 
                raise InspectError("Redefinition of self is not allowed.", self.get_namespace_path(), n)
 
 paul@0    322 
 
 paul@0    323 
            name_ref = expr and self.process_structure_node(expr)
 
 paul@0    324 
 
 paul@0    325 
            # Name assignments populate either function namespaces or the
 
 paul@0    326 
            # general namespace hierarchy.
 
 paul@0    327 
 
 paul@0    328 
            self.assign_general_local(n.name, name_ref)
 
 paul@0    329 
 
 paul@0    330 
            # Record usage of the name.
 
 paul@0    331 
 
 paul@0    332 
            self.record_name(n.name)
 
 paul@0    333 
 
 paul@0    334 
        elif isinstance(n, compiler.ast.AssAttr):
 
 paul@124    335 
            if expr:
 
 paul@124    336 
                expr = self.process_structure_node(expr)
 
 paul@107    337 
 
 paul@107    338 
            in_assignment = self.in_assignment
 
 paul@389    339 
            self.in_assignment = True
 
 paul@0    340 
            self.process_attribute_access(n)
 
 paul@107    341 
            self.in_assignment = in_assignment
 
 paul@0    342 
 
 paul@0    343 
        # Lists and tuples are matched against the expression and their
 
 paul@0    344 
        # items assigned to expression items.
 
 paul@0    345 
 
 paul@0    346 
        elif isinstance(n, (compiler.ast.AssList, compiler.ast.AssTuple)):
 
 paul@0    347 
            self.process_assignment_node_items(n, expr)
 
 paul@0    348 
 
 paul@0    349 
        # Slices and subscripts are permitted within assignment nodes.
 
 paul@0    350 
 
 paul@0    351 
        elif isinstance(n, compiler.ast.Slice):
 
 paul@0    352 
            self.process_slice_node(n, expr)
 
 paul@0    353 
 
 paul@0    354 
        elif isinstance(n, compiler.ast.Subscript):
 
 paul@0    355 
            self.process_subscript_node(n, expr)
 
 paul@0    356 
 
 paul@0    357 
    def process_attribute_access(self, n):
 
 paul@0    358 
 
 paul@0    359 
        "Process the given attribute access node 'n'."
 
 paul@0    360 
 
 paul@845    361 
        path = self.get_namespace_path()
 
 paul@845    362 
 
 paul@845    363 
        # Test for access to special privileged attributes.
 
 paul@845    364 
 
 paul@845    365 
        if isinstance(n, compiler.ast.Getattr) and \
 
 paul@845    366 
           n.attrname in privileged_attributes and not n.privileged:
 
 paul@845    367 
 
 paul@845    368 
            raise InspectError("Attribute %s is accessed by an unprivileged operation." %
 
 paul@845    369 
                               n.attrname, path, n)
 
 paul@845    370 
 
 paul@107    371 
        # Obtain any completed chain and return the reference to it.
 
 paul@107    372 
 
 paul@0    373 
        name_ref = self.process_attribute_chain(n)
 
 paul@107    374 
 
 paul@0    375 
        if self.have_access_expression(n):
 
 paul@0    376 
            return name_ref
 
 paul@0    377 
 
 paul@0    378 
        # Where the start of the chain of attributes has been reached, determine
 
 paul@0    379 
        # the complete access.
 
 paul@0    380 
 
 paul@0    381 
        # Given a non-access node, this chain can be handled in its entirety,
 
 paul@0    382 
        # either being name-based and thus an access rooted on a name, or being
 
 paul@0    383 
        # based on some other node and thus an anonymous access of some kind.
 
 paul@0    384 
 
 paul@0    385 
        # Start with the the full attribute chain.
 
 paul@0    386 
 
 paul@0    387 
        remaining = self.attrs
 
 paul@0    388 
        attrnames = ".".join(remaining)
 
 paul@0    389 
 
 paul@0    390 
        # If the accessor cannot be identified, or where attributes
 
 paul@0    391 
        # remain in an attribute chain, record the anonymous accesses.
 
 paul@0    392 
 
 paul@0    393 
        if not isinstance(name_ref, NameRef): # includes ResolvedNameRef
 
 paul@0    394 
 
 paul@0    395 
            init_item(self.attr_accesses, path, set)
 
 paul@0    396 
            self.attr_accesses[path].add(attrnames)
 
 paul@0    397 
 
 paul@117    398 
            self.record_access_details(None, attrnames, self.in_assignment,
 
 paul@117    399 
                self.in_invocation)
 
 paul@0    400 
            del self.attrs[0]
 
 paul@0    401 
            return
 
 paul@0    402 
 
 paul@0    403 
        # Name-based accesses will handle the first attribute in a
 
 paul@0    404 
        # chain.
 
 paul@0    405 
 
 paul@0    406 
        else:
 
 paul@0    407 
            attrname = remaining[0]
 
 paul@0    408 
 
 paul@0    409 
            # Attribute assignments are used to identify instance attributes.
 
 paul@0    410 
 
 paul@0    411 
            if isinstance(n, compiler.ast.AssAttr) and \
 
 paul@0    412 
                self.in_class and self.in_function and n.expr.name == "self":
 
 paul@0    413 
 
 paul@0    414 
                self.set_instance_attr(attrname)
 
 paul@0    415 
 
 paul@0    416 
            # Record attribute usage using any name local to this namespace,
 
 paul@0    417 
            # if assigned in the namespace, or using an external name
 
 paul@0    418 
            # (presently just globals within classes).
 
 paul@0    419 
 
 paul@603    420 
            name = self.get_name_for_tracking(name_ref.name, name_ref)
 
 paul@0    421 
            tracker = self.trackers[-1]
 
 paul@0    422 
 
 paul@0    423 
            immediate_access = len(self.attrs) == 1
 
 paul@0    424 
            assignment = immediate_access and isinstance(n, compiler.ast.AssAttr)
 
 paul@0    425 
 
 paul@0    426 
            # Record global-based chains for subsequent resolution.
 
 paul@0    427 
 
 paul@603    428 
            if name_ref.is_global_name():
 
 paul@0    429 
                self.record_global_access_details(name, attrnames)
 
 paul@0    430 
 
 paul@0    431 
            # Make sure the name is being tracked: global names will not
 
 paul@0    432 
            # already be initialised in a branch and must be added
 
 paul@0    433 
            # explicitly.
 
 paul@0    434 
 
 paul@0    435 
            if not tracker.have_name(name):
 
 paul@0    436 
                tracker.assign_names([name])
 
 paul@0    437 
                if self.in_function:
 
 paul@0    438 
                    self.scope_globals[path].add(name)
 
 paul@0    439 
 
 paul@0    440 
            # Record attribute usage in the tracker, and record the branch
 
 paul@0    441 
            # information for the access.
 
 paul@0    442 
 
 paul@557    443 
            branches = tracker.use_attribute(name, attrname,
 
 paul@557    444 
                self.in_invocation is not None, assignment)
 
 paul@0    445 
 
 paul@0    446 
            if not branches:
 
 paul@84    447 
                raise InspectError("Name %s is accessed using %s before an assignment." % (
 
 paul@84    448 
                    name, attrname), path, n)
 
 paul@0    449 
 
 paul@0    450 
            self.record_branches_for_access(branches, name, attrnames)
 
 paul@117    451 
            access_number = self.record_access_details(name, attrnames,
 
 paul@117    452 
                self.in_assignment, self.in_invocation)
 
 paul@107    453 
 
 paul@107    454 
            del self.attrs[0]
 
 paul@0    455 
            return AccessRef(name, attrnames, access_number)
 
 paul@0    456 
 
 paul@0    457 
    def process_class_node(self, n):
 
 paul@0    458 
 
 paul@0    459 
        "Process the given class node 'n'."
 
 paul@0    460 
 
 paul@0    461 
        path = self.get_namespace_path()
 
 paul@0    462 
 
 paul@0    463 
        # To avoid notions of class "versions" where the same definition
 
 paul@0    464 
        # might be parameterised with different state and be referenced
 
 paul@0    465 
        # elsewhere (as base classes, for example), classes in functions or
 
 paul@0    466 
        # conditions are forbidden.
 
 paul@0    467 
 
 paul@0    468 
        if self.in_function or self.in_conditional:
 
 paul@0    469 
            print >>sys.stderr, "In %s, class %s in function or conditional statement ignored." % (
 
 paul@0    470 
                path, n.name)
 
 paul@0    471 
            return
 
 paul@0    472 
 
 paul@0    473 
        # Resolve base classes.
 
 paul@0    474 
 
 paul@0    475 
        bases = []
 
 paul@0    476 
 
 paul@0    477 
        for base in n.bases:
 
 paul@0    478 
            base_class = self.get_class(base)
 
 paul@0    479 
 
 paul@0    480 
            if not base_class:
 
 paul@12    481 
                print >>sys.stderr, "In %s, class %s has unidentifiable base class: %s" % (
 
 paul@12    482 
                    path, n.name, base)
 
 paul@0    483 
                return
 
 paul@0    484 
            else:
 
 paul@0    485 
                bases.append(base_class)
 
 paul@0    486 
 
 paul@348    487 
        # Detect conflicting definitions. Such definitions cause conflicts in
 
 paul@348    488 
        # the storage of namespace-related information.
 
 paul@348    489 
 
 paul@348    490 
        class_name = self.get_object_path(n.name)
 
 paul@422    491 
        ref = self.get_object(class_name, defer=False)
 
 paul@348    492 
 
 paul@422    493 
        if ref and ref.static():
 
 paul@348    494 
            raise InspectError("Multiple definitions for the same name are not permitted.", class_name, n)
 
 paul@348    495 
 
 paul@0    496 
        # Record bases for the class and retain the class name.
 
 paul@107    497 
        # Note that the function class does not inherit from the object class.
 
 paul@0    498 
 
 paul@107    499 
        if not bases and class_name != "__builtins__.core.object" and \
 
 paul@107    500 
                         class_name != "__builtins__.core.function":
 
 paul@107    501 
 
 paul@0    502 
            ref = self.get_object("__builtins__.object")
 
 paul@0    503 
            bases.append(ref)
 
 paul@0    504 
 
 paul@0    505 
        self.importer.classes[class_name] = self.classes[class_name] = bases
 
 paul@0    506 
        self.importer.subclasses[class_name] = set()
 
 paul@0    507 
        self.scope_globals[class_name] = set()
 
 paul@0    508 
 
 paul@0    509 
        # Set the definition before entering the namespace rather than
 
 paul@0    510 
        # afterwards because methods may reference it. In normal Python,
 
 paul@0    511 
        # a class is not accessible until the definition is complete, but
 
 paul@0    512 
        # methods can generally reference it since upon being called the
 
 paul@0    513 
        # class will already exist.
 
 paul@0    514 
 
 paul@0    515 
        self.set_definition(n.name, "<class>")
 
 paul@0    516 
 
 paul@0    517 
        in_class = self.in_class
 
 paul@0    518 
        self.in_class = class_name
 
 paul@0    519 
        self.set_instance_attr("__class__", Reference("<class>", class_name))
 
 paul@0    520 
        self.enter_namespace(n.name)
 
 paul@107    521 
 
 paul@107    522 
        # Do not provide the special instantiator attributes on the function
 
 paul@107    523 
        # class. Function instances provide these attributes.
 
 paul@107    524 
 
 paul@107    525 
        if class_name != "__builtins__.core.function":
 
 paul@577    526 
 
 paul@107    527 
            self.set_name("__fn__") # special instantiator attribute
 
 paul@107    528 
            self.set_name("__args__") # special instantiator attribute
 
 paul@107    529 
 
 paul@577    530 
        # Provide leafname, parent and context attributes.
 
 paul@489    531 
 
 paul@499    532 
        parent, leafname = class_name.rsplit(".", 1)
 
 paul@938    533 
        self.set_name("__name__", self.get_constant("str", leafname).reference())
 
 paul@577    534 
 
 paul@577    535 
        if class_name != "__builtins__.core.function":
 
 paul@577    536 
            self.set_name("__parent__")
 
 paul@274    537 
 
 paul@0    538 
        self.process_structure_node(n.code)
 
 paul@0    539 
        self.exit_namespace()
 
 paul@0    540 
        self.in_class = in_class
 
 paul@0    541 
 
 paul@0    542 
    def process_from_node(self, n):
 
 paul@0    543 
 
 paul@0    544 
        "Process the given node 'n', importing from another module."
 
 paul@0    545 
 
 paul@0    546 
        path = self.get_namespace_path()
 
 paul@0    547 
 
 paul@12    548 
        module_name, names = self.get_module_name(n)
 
 paul@12    549 
        if module_name == self.name:
 
 paul@12    550 
            raise InspectError("Cannot import from the current module.", path, n)
 
 paul@0    551 
 
 paul@18    552 
        self.queue_module(module_name)
 
 paul@0    553 
 
 paul@0    554 
        # Attempt to obtain the referenced objects.
 
 paul@0    555 
 
 paul@0    556 
        for name, alias in n.names:
 
 paul@0    557 
            if name == "*":
 
 paul@12    558 
                raise InspectError("Only explicitly specified names can be imported from modules.", path, n)
 
 paul@0    559 
 
 paul@0    560 
            # Explicit names.
 
 paul@0    561 
 
 paul@12    562 
            ref = self.import_name_from_module(name, module_name)
 
 paul@0    563 
            value = ResolvedNameRef(alias or name, ref)
 
 paul@0    564 
            self.set_general_local(alias or name, value)
 
 paul@0    565 
 
 paul@0    566 
    def process_function_node(self, n, name):
 
 paul@0    567 
 
 paul@0    568 
        """
 
 paul@0    569 
        Process the given function or lambda node 'n' with the given 'name'.
 
 paul@0    570 
        """
 
 paul@0    571 
 
 paul@0    572 
        is_lambda = isinstance(n, compiler.ast.Lambda)
 
 paul@0    573 
 
 paul@0    574 
        # Where a function is declared conditionally, use a separate name for
 
 paul@0    575 
        # the definition, and assign the definition to the stated name.
 
 paul@0    576 
 
 paul@0    577 
        if (self.in_conditional or self.in_function) and not is_lambda:
 
 paul@0    578 
            original_name = name
 
 paul@0    579 
            name = self.get_lambda_name()
 
 paul@0    580 
        else:
 
 paul@0    581 
            original_name = None
 
 paul@0    582 
 
 paul@348    583 
        # Detect conflicting definitions. Such definitions cause conflicts in
 
 paul@348    584 
        # the storage of namespace-related information.
 
 paul@348    585 
 
 paul@348    586 
        function_name = self.get_object_path(name)
 
 paul@422    587 
        ref = self.get_object(function_name, defer=False)
 
 paul@348    588 
 
 paul@422    589 
        if ref and ref.static():
 
 paul@348    590 
            raise InspectError("Multiple definitions for the same name are not permitted.", function_name, n)
 
 paul@348    591 
 
 paul@0    592 
        # Initialise argument and local records.
 
 paul@0    593 
 
 paul@46    594 
        argnames = get_argnames(n.argnames)
 
 paul@48    595 
        is_method = self.in_class and not self.in_function
 
 paul@0    596 
 
 paul@48    597 
        # Remove explicit "self" from method parameters.
 
 paul@46    598 
 
 paul@48    599 
        if is_method and argnames and argnames[0] == "self":
 
 paul@48    600 
            del argnames[0]
 
 paul@48    601 
 
 paul@819    602 
        # Convert .name entries in the parameters, provided this is a method.
 
 paul@819    603 
 
 paul@819    604 
        l = []
 
 paul@819    605 
        attr_initialisers = []
 
 paul@819    606 
 
 paul@819    607 
        for argname in argnames:
 
 paul@819    608 
            if argname[0] == ".":
 
 paul@819    609 
                if not is_method:
 
 paul@819    610 
                    raise InspectError("Attribute initialisers are only allowed amongst method parameters.", function_name, n)
 
 paul@819    611 
 
 paul@819    612 
                argname = argname[1:]
 
 paul@819    613 
                attr_initialisers.append(argname)
 
 paul@819    614 
 
 paul@820    615 
            if argname in l:
 
 paul@820    616 
                raise InspectError("Argument name %s is repeated." % argname, function_name, n)
 
 paul@820    617 
 
 paul@819    618 
            l.append(argname)
 
 paul@819    619 
 
 paul@819    620 
        argnames = l
 
 paul@819    621 
 
 paul@48    622 
        # Copy and propagate the parameters.
 
 paul@46    623 
 
 paul@46    624 
        self.importer.function_parameters[function_name] = \
 
 paul@109    625 
            self.function_parameters[function_name] = argnames[:]
 
 paul@46    626 
 
 paul@819    627 
        self.importer.function_attr_initialisers[function_name] = \
 
 paul@819    628 
            self.function_attr_initialisers[function_name] = attr_initialisers
 
 paul@819    629 
 
 paul@46    630 
        # Define all arguments/parameters in the local namespace.
 
 paul@46    631 
 
 paul@109    632 
        locals = \
 
 paul@109    633 
            self.importer.function_locals[function_name] = \
 
 paul@109    634 
            self.function_locals[function_name] = {}
 
 paul@0    635 
 
 paul@48    636 
        # Insert "self" into method locals.
 
 paul@48    637 
 
 paul@48    638 
        if is_method:
 
 paul@48    639 
            argnames.insert(0, "self")
 
 paul@48    640 
 
 paul@47    641 
        # Define "self" in terms of the class if in a method.
 
 paul@47    642 
        # This does not diminish the need for type-narrowing in the deducer.
 
 paul@47    643 
 
 paul@47    644 
        if argnames:
 
 paul@48    645 
            if self.in_class and not self.in_function and argnames[0] == "self":
 
 paul@47    646 
                locals[argnames[0]] = Reference("<instance>", self.in_class)
 
 paul@47    647 
            else:
 
 paul@47    648 
                locals[argnames[0]] = Reference("<var>")
 
 paul@47    649 
 
 paul@47    650 
        for argname in argnames[1:]:
 
 paul@0    651 
            locals[argname] = Reference("<var>")
 
 paul@0    652 
 
 paul@0    653 
        globals = self.scope_globals[function_name] = set()
 
 paul@0    654 
 
 paul@0    655 
        # Process the defaults.
 
 paul@0    656 
 
 paul@0    657 
        defaults = self.importer.function_defaults[function_name] = \
 
 paul@0    658 
                   self.function_defaults[function_name] = []
 
 paul@0    659 
 
 paul@0    660 
        for argname, default in compiler.ast.get_defaults(n):
 
 paul@906    661 
            if argname[0] == ".":
 
 paul@906    662 
                argname = argname[1:]
 
 paul@906    663 
 
 paul@0    664 
            if default:
 
 paul@0    665 
 
 paul@0    666 
                # Obtain any reference for the default.
 
 paul@0    667 
 
 paul@0    668 
                name_ref = self.process_structure_node(default)
 
 paul@0    669 
                defaults.append((argname, name_ref.is_name() and name_ref.reference() or Reference("<var>")))
 
 paul@0    670 
 
 paul@0    671 
        # Reset conditional tracking to focus on the function contents.
 
 paul@0    672 
 
 paul@0    673 
        in_conditional = self.in_conditional
 
 paul@0    674 
        self.in_conditional = False
 
 paul@0    675 
 
 paul@0    676 
        in_function = self.in_function
 
 paul@0    677 
        self.in_function = function_name
 
 paul@0    678 
 
 paul@0    679 
        self.enter_namespace(name)
 
 paul@0    680 
 
 paul@499    681 
        # Define a leafname attribute value for the function instance.
 
 paul@251    682 
 
 paul@938    683 
        ref = self.get_builtin_class("str")
 
 paul@489    684 
        self.reserve_constant(function_name, name, ref.get_origin())
 
 paul@251    685 
 
 paul@0    686 
        # Track attribute usage within the namespace.
 
 paul@0    687 
 
 paul@0    688 
        path = self.get_namespace_path()
 
 paul@819    689 
        self.start_tracking(locals)
 
 paul@0    690 
 
 paul@819    691 
        # Establish attributes for .name entries, provided this is a method.
 
 paul@819    692 
 
 paul@819    693 
        for argname in attr_initialisers:
 
 paul@819    694 
            self.process_assignment_node(
 
 paul@819    695 
                    compiler.ast.AssAttr(compiler.ast.Name("self"), argname, "OP_ASSIGN"),
 
 paul@819    696 
                    compiler.ast.Name(argname))
 
 paul@819    697 
 
 paul@0    698 
        self.process_structure_node(n.code)
 
 paul@703    699 
        returns_value = self.stop_tracking()
 
 paul@703    700 
 
 paul@703    701 
        # Record any null result.
 
 paul@703    702 
 
 paul@703    703 
        is_initialiser = is_method and name == "__init__"
 
 paul@703    704 
 
 paul@703    705 
        if not returns_value and not is_initialiser:
 
 paul@703    706 
            self.record_return_value(ResolvedNameRef("None", self.get_builtin("None")))
 
 paul@0    707 
 
 paul@1    708 
        # Exit to the parent.
 
 paul@0    709 
 
 paul@0    710 
        self.exit_namespace()
 
 paul@0    711 
 
 paul@0    712 
        # Update flags.
 
 paul@0    713 
 
 paul@0    714 
        self.in_function = in_function
 
 paul@0    715 
        self.in_conditional = in_conditional
 
 paul@0    716 
 
 paul@0    717 
        # Define the function using the appropriate name.
 
 paul@0    718 
 
 paul@0    719 
        self.set_definition(name, "<function>")
 
 paul@0    720 
 
 paul@0    721 
        # Where a function is set conditionally, assign the name.
 
 paul@0    722 
 
 paul@0    723 
        if original_name:
 
 paul@322    724 
            self.process_assignment_for_object(original_name, compiler.ast.Name(name))
 
 paul@0    725 
 
 paul@0    726 
    def process_global_node(self, n):
 
 paul@0    727 
 
 paul@0    728 
        """
 
 paul@0    729 
        Process the given "global" node 'n'.
 
 paul@0    730 
        """
 
 paul@0    731 
 
 paul@0    732 
        path = self.get_namespace_path()
 
 paul@0    733 
 
 paul@0    734 
        if path != self.name:
 
 paul@0    735 
            self.scope_globals[path].update(n.names)
 
 paul@0    736 
 
 paul@0    737 
    def process_if_node(self, n):
 
 paul@0    738 
 
 paul@0    739 
        """
 
 paul@0    740 
        Process the given "if" node 'n'.
 
 paul@0    741 
        """
 
 paul@0    742 
 
 paul@0    743 
        tracker = self.trackers[-1]
 
 paul@0    744 
        tracker.new_branchpoint()
 
 paul@0    745 
 
 paul@0    746 
        for test, body in n.tests:
 
 paul@0    747 
            self.process_structure_node(test)
 
 paul@0    748 
 
 paul@0    749 
            tracker.new_branch()
 
 paul@0    750 
 
 paul@0    751 
            in_conditional = self.in_conditional
 
 paul@0    752 
            self.in_conditional = True
 
 paul@0    753 
            self.process_structure_node(body)
 
 paul@0    754 
            self.in_conditional = in_conditional
 
 paul@0    755 
 
 paul@0    756 
            tracker.shelve_branch()
 
 paul@0    757 
 
 paul@0    758 
        # Maintain a branch for the else clause.
 
 paul@0    759 
 
 paul@0    760 
        tracker.new_branch()
 
 paul@0    761 
        if n.else_:
 
 paul@0    762 
            self.process_structure_node(n.else_)
 
 paul@0    763 
        tracker.shelve_branch()
 
 paul@0    764 
 
 paul@0    765 
        tracker.merge_branches()
 
 paul@0    766 
 
 paul@0    767 
    def process_import_node(self, n):
 
 paul@0    768 
 
 paul@0    769 
        "Process the given import node 'n'."
 
 paul@0    770 
 
 paul@0    771 
        path = self.get_namespace_path()
 
 paul@0    772 
 
 paul@0    773 
        # Load the mentioned module.
 
 paul@0    774 
 
 paul@0    775 
        for name, alias in n.names:
 
 paul@12    776 
            if name == self.name:
 
 paul@12    777 
                raise InspectError("Cannot import the current module.", path, n)
 
 paul@0    778 
 
 paul@13    779 
            self.set_module(alias or name.split(".")[-1], name)
 
 paul@18    780 
            self.queue_module(name, True)
 
 paul@0    781 
 
 paul@0    782 
    def process_invocation_node(self, n):
 
 paul@0    783 
 
 paul@0    784 
        "Process the given invocation node 'n'."
 
 paul@0    785 
 
 paul@0    786 
        path = self.get_namespace_path()
 
 paul@0    787 
 
 paul@676    788 
        in_invocation = self.in_invocation
 
 paul@676    789 
        self.in_invocation = None
 
 paul@0    790 
 
 paul@676    791 
        # Process the arguments.
 
 paul@557    792 
 
 paul@676    793 
        keywords = set()
 
 paul@557    794 
 
 paul@676    795 
        for arg in n.args:
 
 paul@676    796 
            self.process_structure_node(arg)
 
 paul@676    797 
            if isinstance(arg, compiler.ast.Keyword):
 
 paul@676    798 
                keywords.add(arg.name)
 
 paul@557    799 
 
 paul@676    800 
        keywords = list(keywords)
 
 paul@676    801 
        keywords.sort()
 
 paul@557    802 
 
 paul@676    803 
        # Communicate to the invocation target expression that it forms the
 
 paul@676    804 
        # target of an invocation, potentially affecting attribute accesses.
 
 paul@0    805 
 
 paul@676    806 
        self.in_invocation = len(n.args), keywords
 
 paul@107    807 
 
 paul@676    808 
        # Process the expression, obtaining any identified reference.
 
 paul@107    809 
 
 paul@676    810 
        name_ref = self.process_structure_node(n.node)
 
 paul@676    811 
        self.in_invocation = in_invocation
 
 paul@223    812 
 
 paul@676    813 
        # Detect class invocations.
 
 paul@0    814 
 
 paul@676    815 
        if isinstance(name_ref, ResolvedNameRef) and name_ref.has_kind("<class>"):
 
 paul@676    816 
            return InstanceRef(name_ref.reference().instance_of())
 
 paul@676    817 
 
 paul@709    818 
        elif isinstance(name_ref, (NameRef, AccessRef)):
 
 paul@676    819 
            return InvocationRef(name_ref)
 
 paul@0    820 
 
 paul@676    821 
        # Provide a general reference to indicate that something is produced
 
 paul@676    822 
        # by the invocation, useful for retaining assignment expression
 
 paul@676    823 
        # details.
 
 paul@226    824 
 
 paul@676    825 
        return VariableRef()
 
 paul@0    826 
 
 paul@0    827 
    def process_lambda_node(self, n):
 
 paul@0    828 
 
 paul@0    829 
        "Process the given lambda node 'n'."
 
 paul@0    830 
 
 paul@0    831 
        name = self.get_lambda_name()
 
 paul@0    832 
        self.process_function_node(n, name)
 
 paul@0    833 
 
 paul@0    834 
        origin = self.get_object_path(name)
 
 paul@210    835 
 
 paul@210    836 
        if self.function_defaults.get(origin):
 
 paul@210    837 
            return None
 
 paul@210    838 
        else:
 
 paul@210    839 
            return ResolvedNameRef(name, Reference("<function>", origin))
 
 paul@0    840 
 
 paul@0    841 
    def process_logical_node(self, n):
 
 paul@0    842 
 
 paul@0    843 
        "Process the given operator node 'n'."
 
 paul@0    844 
 
 paul@794    845 
        return self.process_operator_chain(n.nodes)
 
 paul@0    846 
 
 paul@0    847 
    def process_name_node(self, n):
 
 paul@0    848 
 
 paul@0    849 
        "Process the given name node 'n'."
 
 paul@0    850 
 
 paul@0    851 
        path = self.get_namespace_path()
 
 paul@0    852 
 
 paul@420    853 
        # Find predefined constant names before anything else.
 
 paul@420    854 
 
 paul@420    855 
        if n.name in predefined_constants:
 
 paul@420    856 
            ref = self.get_builtin(n.name)
 
 paul@420    857 
            value = ResolvedNameRef(n.name, ref)
 
 paul@420    858 
            return value
 
 paul@420    859 
 
 paul@173    860 
        # Special names that have already been identified.
 
 paul@0    861 
 
 paul@0    862 
        if n.name.startswith("$"):
 
 paul@0    863 
            value = self.get_special(n.name)
 
 paul@0    864 
            if value:
 
 paul@0    865 
                return value
 
 paul@0    866 
 
 paul@0    867 
        # Special case for operator functions introduced through code
 
 paul@0    868 
        # transformations.
 
 paul@0    869 
 
 paul@0    870 
        if n.name.startswith("$op"):
 
 paul@0    871 
 
 paul@0    872 
            # Obtain the location of the actual function defined in the operator
 
 paul@0    873 
            # package.
 
 paul@0    874 
 
 paul@0    875 
            op = n.name[len("$op"):]
 
 paul@0    876 
 
 paul@0    877 
            # Attempt to get a reference.
 
 paul@0    878 
 
 paul@12    879 
            ref = self.import_name_from_module(op, "operator")
 
 paul@0    880 
 
 paul@0    881 
            # Record the imported name and provide the resolved name reference.
 
 paul@0    882 
 
 paul@0    883 
            value = ResolvedNameRef(n.name, ref)
 
 paul@0    884 
            self.set_special(n.name, value)
 
 paul@0    885 
            return value
 
 paul@0    886 
 
 paul@835    887 
        # Special case for sequence length testing.
 
 paul@835    888 
 
 paul@835    889 
        elif n.name.startswith("$seq"):
 
 paul@835    890 
            op = n.name[len("$seq"):]
 
 paul@835    891 
            ref = self.import_name_from_module(op, "__builtins__.sequence")
 
 paul@835    892 
            value = ResolvedNameRef(n.name, ref)
 
 paul@835    893 
            self.set_special(n.name, value)
 
 paul@835    894 
            return value
 
 paul@835    895 
 
 paul@173    896 
        # Special case for print operations.
 
 paul@173    897 
 
 paul@173    898 
        elif n.name.startswith("$print"):
 
 paul@173    899 
 
 paul@173    900 
            # Attempt to get a reference.
 
 paul@173    901 
 
 paul@173    902 
            ref = self.get_builtin("print_")
 
 paul@173    903 
 
 paul@173    904 
            # Record the imported name and provide the resolved name reference.
 
 paul@173    905 
 
 paul@173    906 
            value = ResolvedNameRef(n.name, ref)
 
 paul@173    907 
            self.set_special(n.name, value)
 
 paul@173    908 
            return value
 
 paul@173    909 
 
 paul@60    910 
        # Test for self usage, which is only allowed in methods.
 
 paul@60    911 
 
 paul@60    912 
        if n.name == "self" and not (self.in_function and self.in_class):
 
 paul@60    913 
            raise InspectError("Use of self is only allowed in methods.", path, n)
 
 paul@60    914 
 
 paul@0    915 
        # Record usage of the name.
 
 paul@0    916 
 
 paul@0    917 
        self.record_name(n.name)
 
 paul@0    918 
 
 paul@0    919 
        # Search for unknown names in non-function scopes immediately.
 
 paul@779    920 
        # Temporary names should not be re-used between scopes.
 
 paul@0    921 
        # External names in functions are resolved later.
 
 paul@0    922 
 
 paul@779    923 
        ref = not n.name.startswith("$t") and self.find_name(n.name) or None
 
 paul@779    924 
 
 paul@0    925 
        if ref:
 
 paul@684    926 
            self.record_name_access(n.name, True)
 
 paul@603    927 
            return ResolvedNameRef(n.name, ref, is_global=True)
 
 paul@0    928 
 
 paul@40    929 
        # Explicitly-declared global names.
 
 paul@0    930 
 
 paul@0    931 
        elif self.in_function and n.name in self.scope_globals[path]:
 
 paul@684    932 
            self.record_name_access(n.name, True)
 
 paul@603    933 
            return NameRef(n.name, is_global=True)
 
 paul@0    934 
 
 paul@0    935 
        # Examine other names.
 
 paul@0    936 
 
 paul@0    937 
        else:
 
 paul@0    938 
 
 paul@0    939 
            # Check local names.
 
 paul@0    940 
 
 paul@684    941 
            access_number = self.record_name_access(n.name)
 
 paul@0    942 
 
 paul@1    943 
            # Local name.
 
 paul@0    944 
 
 paul@684    945 
            if access_number is not None:
 
 paul@0    946 
                return LocalNameRef(n.name, access_number)
 
 paul@0    947 
 
 paul@40    948 
            # Possible global or built-in name.
 
 paul@0    949 
 
 paul@0    950 
            else:
 
 paul@684    951 
                self.record_name_access(n.name, True)
 
 paul@603    952 
                return NameRef(n.name, is_global=True)
 
 paul@0    953 
 
 paul@684    954 
    def record_name_access(self, name, is_global=False):
 
 paul@684    955 
 
 paul@684    956 
        """
 
 paul@684    957 
        Record an access involving 'name' if the name is being tracked, using
 
 paul@684    958 
        'is_global' to indicate whether the name is global.
 
 paul@684    959 
        """
 
 paul@684    960 
 
 paul@684    961 
        name = self.get_name_for_tracking(name, is_global=is_global)
 
 paul@684    962 
        branches = self.trackers[-1].tracking_name(name)
 
 paul@684    963 
        if branches:
 
 paul@684    964 
            self.record_branches_for_access(branches, name, None)
 
 paul@717    965 
            return self.record_access_details(name, None, self.in_assignment,
 
 paul@717    966 
                                              self.in_invocation)
 
 paul@684    967 
        return None
 
 paul@684    968 
 
 paul@794    969 
    def process_operator_chain(self, nodes):
 
 paul@0    970 
 
 paul@0    971 
        """
 
 paul@794    972 
        Process the given chain of 'nodes', processing each node or item.
 
 paul@0    973 
        Each node starts a new conditional region, effectively making a deeply-
 
 paul@0    974 
        nested collection of if-like statements.
 
 paul@0    975 
        """
 
 paul@0    976 
 
 paul@794    977 
        results = []
 
 paul@794    978 
 
 paul@0    979 
        tracker = self.trackers[-1]
 
 paul@0    980 
 
 paul@0    981 
        for item in nodes:
 
 paul@0    982 
            tracker.new_branchpoint()
 
 paul@0    983 
            tracker.new_branch()
 
 paul@794    984 
            result = self.process_structure_node(item)
 
 paul@794    985 
            if result:
 
 paul@794    986 
                results.append(result)
 
 paul@0    987 
 
 paul@0    988 
        for item in nodes[:-1]:
 
 paul@0    989 
            tracker.shelve_branch()
 
 paul@0    990 
            tracker.new_branch()
 
 paul@0    991 
            tracker.shelve_branch()
 
 paul@0    992 
            tracker.merge_branches()
 
 paul@0    993 
 
 paul@0    994 
        tracker.shelve_branch()
 
 paul@0    995 
        tracker.merge_branches()
 
 paul@0    996 
 
 paul@794    997 
        return MultipleRef(results)
 
 paul@794    998 
 
 paul@0    999 
    def process_try_node(self, n):
 
 paul@0   1000 
 
 paul@0   1001 
        """
 
 paul@0   1002 
        Process the given "try...except" node 'n'.
 
 paul@0   1003 
        """
 
 paul@0   1004 
 
 paul@479   1005 
        self.record_exception_handler()
 
 paul@479   1006 
 
 paul@0   1007 
        tracker = self.trackers[-1]
 
 paul@0   1008 
        tracker.new_branchpoint()
 
 paul@0   1009 
 
 paul@0   1010 
        self.process_structure_node(n.body)
 
 paul@0   1011 
 
 paul@0   1012 
        for name, var, handler in n.handlers:
 
 paul@0   1013 
            if name is not None:
 
 paul@0   1014 
                self.process_structure_node(name)
 
 paul@0   1015 
 
 paul@0   1016 
            # Any abandoned branches from the body can now be resumed in a new
 
 paul@0   1017 
            # branch.
 
 paul@0   1018 
 
 paul@0   1019 
            tracker.resume_abandoned_branches()
 
 paul@0   1020 
 
 paul@0   1021 
            # Establish the local for the handler.
 
 paul@0   1022 
 
 paul@0   1023 
            if var is not None:
 
 paul@261   1024 
                self.process_assignment_node(var, None)
 
 paul@0   1025 
            if handler is not None:
 
 paul@0   1026 
                self.process_structure_node(handler)
 
 paul@0   1027 
 
 paul@0   1028 
            tracker.shelve_branch()
 
 paul@0   1029 
 
 paul@0   1030 
        # The else clause maintains the usage from the body but without the
 
 paul@0   1031 
        # abandoned branches since they would never lead to the else clause
 
 paul@0   1032 
        # being executed.
 
 paul@0   1033 
 
 paul@0   1034 
        if n.else_:
 
 paul@0   1035 
            tracker.new_branch()
 
 paul@0   1036 
            self.process_structure_node(n.else_)
 
 paul@0   1037 
            tracker.shelve_branch()
 
 paul@0   1038 
 
 paul@0   1039 
        # Without an else clause, a null branch propagates the successful
 
 paul@0   1040 
        # outcome.
 
 paul@0   1041 
 
 paul@0   1042 
        else:
 
 paul@0   1043 
            tracker.new_branch()
 
 paul@0   1044 
            tracker.shelve_branch()
 
 paul@0   1045 
 
 paul@0   1046 
        tracker.merge_branches()
 
 paul@0   1047 
 
 paul@0   1048 
    def process_try_finally_node(self, n):
 
 paul@0   1049 
 
 paul@0   1050 
        """
 
 paul@0   1051 
        Process the given "try...finally" node 'n'.
 
 paul@0   1052 
        """
 
 paul@0   1053 
 
 paul@479   1054 
        self.record_exception_handler()
 
 paul@479   1055 
 
 paul@0   1056 
        tracker = self.trackers[-1]
 
 paul@0   1057 
        self.process_structure_node(n.body)
 
 paul@0   1058 
 
 paul@0   1059 
        # Any abandoned branches from the body can now be resumed.
 
 paul@0   1060 
 
 paul@0   1061 
        branches = tracker.resume_all_abandoned_branches()
 
 paul@0   1062 
        self.process_structure_node(n.final)
 
 paul@0   1063 
 
 paul@0   1064 
        # At the end of the finally clause, abandoned branches are discarded.
 
 paul@0   1065 
 
 paul@0   1066 
        tracker.restore_active_branches(branches)
 
 paul@0   1067 
 
 paul@0   1068 
    def process_while_node(self, n):
 
 paul@0   1069 
 
 paul@0   1070 
        "Process the given while node 'n'."
 
 paul@0   1071 
 
 paul@0   1072 
        tracker = self.trackers[-1]
 
 paul@0   1073 
        tracker.new_branchpoint(loop_node=True)
 
 paul@0   1074 
 
 paul@0   1075 
        # Evaluate any test or iterator outside the loop.
 
 paul@0   1076 
 
 paul@0   1077 
        self.process_structure_node(n.test)
 
 paul@0   1078 
 
 paul@0   1079 
        # Propagate attribute usage to branches.
 
 paul@0   1080 
 
 paul@0   1081 
        tracker.new_branch(loop_node=True)
 
 paul@0   1082 
 
 paul@0   1083 
        # Enter the loop.
 
 paul@0   1084 
 
 paul@0   1085 
        in_conditional = self.in_conditional
 
 paul@0   1086 
        self.in_conditional = True
 
 paul@0   1087 
        self.process_structure_node(n.body)
 
 paul@0   1088 
        self.in_conditional = in_conditional
 
 paul@0   1089 
 
 paul@0   1090 
        # Continuing branches are resumed before any test.
 
 paul@0   1091 
 
 paul@0   1092 
        tracker.resume_continuing_branches()
 
 paul@0   1093 
 
 paul@0   1094 
        # Evaluate any continuation test within the body.
 
 paul@0   1095 
 
 paul@0   1096 
        self.process_structure_node(n.test)
 
 paul@0   1097 
 
 paul@0   1098 
        tracker.shelve_branch(loop_node=True)
 
 paul@0   1099 
 
 paul@0   1100 
        # Support the non-looping condition.
 
 paul@0   1101 
 
 paul@0   1102 
        tracker.new_branch()
 
 paul@0   1103 
        tracker.shelve_branch()
 
 paul@0   1104 
 
 paul@0   1105 
        tracker.merge_branches()
 
 paul@0   1106 
 
 paul@0   1107 
        # Evaluate any else clause outside branches.
 
 paul@0   1108 
 
 paul@0   1109 
        if n.else_:
 
 paul@0   1110 
            self.process_structure_node(n.else_)
 
 paul@0   1111 
 
 paul@0   1112 
        # Connect broken branches to the code after any loop.
 
 paul@0   1113 
 
 paul@0   1114 
        tracker.resume_broken_branches()
 
 paul@0   1115 
 
 paul@0   1116 
    # Branch tracking methods.
 
 paul@0   1117 
 
 paul@0   1118 
    def start_tracking(self, names):
 
 paul@0   1119 
 
 paul@0   1120 
        """
 
 paul@0   1121 
        Start tracking attribute usage for names in the current namespace,
 
 paul@0   1122 
        immediately registering the given 'names'.
 
 paul@0   1123 
        """
 
 paul@0   1124 
 
 paul@0   1125 
        path = self.get_namespace_path()
 
 paul@0   1126 
        parent = self.trackers[-1]
 
 paul@0   1127 
        tracker = BranchTracker()
 
 paul@0   1128 
        self.trackers.append(tracker)
 
 paul@0   1129 
 
 paul@0   1130 
        # Record the given names established as new branches.
 
 paul@0   1131 
 
 paul@0   1132 
        tracker.assign_names(names)
 
 paul@0   1133 
 
 paul@0   1134 
    def assign_name(self, name, name_ref):
 
 paul@0   1135 
 
 paul@0   1136 
        "Assign to 'name' the given 'name_ref' in the current namespace."
 
 paul@0   1137 
 
 paul@0   1138 
        name = self.get_name_for_tracking(name)
 
 paul@0   1139 
        self.trackers[-1].assign_names([name], [name_ref])
 
 paul@0   1140 
 
 paul@0   1141 
    def stop_tracking(self):
 
 paul@0   1142 
 
 paul@0   1143 
        """
 
 paul@0   1144 
        Stop tracking attribute usage, recording computed usage for the current
 
 paul@703   1145 
        namespace. Indicate whether a value is always returned from the
 
 paul@0   1146 
        namespace.
 
 paul@0   1147 
        """
 
 paul@0   1148 
 
 paul@0   1149 
        path = self.get_namespace_path()
 
 paul@0   1150 
        tracker = self.trackers.pop()
 
 paul@0   1151 
        self.record_assignments_for_access(tracker)
 
 paul@0   1152 
 
 paul@0   1153 
        self.attr_usage[path] = tracker.get_all_usage()
 
 paul@0   1154 
        self.name_initialisers[path] = tracker.get_all_values()
 
 paul@0   1155 
 
 paul@703   1156 
        return tracker.returns_value()
 
 paul@703   1157 
 
 paul@0   1158 
    def start_tracking_in_module(self):
 
 paul@0   1159 
 
 paul@0   1160 
        "Start tracking attribute usage in the module."
 
 paul@0   1161 
 
 paul@0   1162 
        tracker = BranchTracker()
 
 paul@0   1163 
        self.trackers.append(tracker)
 
 paul@0   1164 
 
 paul@0   1165 
    def stop_tracking_in_module(self):
 
 paul@0   1166 
 
 paul@0   1167 
        "Stop tracking attribute usage in the module."
 
 paul@0   1168 
 
 paul@0   1169 
        tracker = self.trackers[0]
 
 paul@0   1170 
        self.record_assignments_for_access(tracker)
 
 paul@0   1171 
        self.attr_usage[self.name] = tracker.get_all_usage()
 
 paul@0   1172 
        self.name_initialisers[self.name] = tracker.get_all_values()
 
 paul@0   1173 
 
 paul@0   1174 
    def record_assignments_for_access(self, tracker):
 
 paul@0   1175 
 
 paul@0   1176 
        """
 
 paul@0   1177 
        For the current path, use the given 'tracker' to record assignment
 
 paul@0   1178 
        version information for attribute accesses.
 
 paul@0   1179 
        """
 
 paul@0   1180 
 
 paul@0   1181 
        path = self.get_path_for_access()
 
 paul@0   1182 
 
 paul@0   1183 
        if not self.attr_accessor_branches.has_key(path):
 
 paul@0   1184 
            return
 
 paul@0   1185 
 
 paul@0   1186 
        init_item(self.attr_accessors, path, dict)
 
 paul@0   1187 
        attr_accessors = self.attr_accessors[path]
 
 paul@0   1188 
 
 paul@0   1189 
        # Obtain the branches applying during each access.
 
 paul@0   1190 
 
 paul@0   1191 
        for access, all_branches in self.attr_accessor_branches[path].items():
 
 paul@0   1192 
            name, attrnames = access
 
 paul@0   1193 
            init_item(attr_accessors, access, list)
 
 paul@0   1194 
 
 paul@0   1195 
            # Obtain the assignments applying to each branch.
 
 paul@0   1196 
 
 paul@0   1197 
            for branches in all_branches:
 
 paul@0   1198 
                positions = tracker.get_assignment_positions_for_branches(name, branches)
 
 paul@0   1199 
 
 paul@0   1200 
                # Detect missing name information.
 
 paul@0   1201 
 
 paul@0   1202 
                if None in positions:
 
 paul@0   1203 
                    globals = self.global_attr_accesses.get(path)
 
 paul@0   1204 
                    accesses = globals and globals.get(name)
 
 paul@0   1205 
                    if not accesses:
 
 paul@0   1206 
                        print >>sys.stderr, "In %s, %s may not be defined when used." % (
 
 paul@0   1207 
                            self.get_namespace_path(), name)
 
 paul@0   1208 
                    positions.remove(None)
 
 paul@0   1209 
 
 paul@0   1210 
                attr_accessors[access].append(positions)
 
 paul@0   1211 
 
 paul@0   1212 
    def record_branches_for_access(self, branches, name, attrnames):
 
 paul@0   1213 
 
 paul@0   1214 
        """
 
 paul@0   1215 
        Record the given 'branches' for an access involving the given 'name' and
 
 paul@0   1216 
        'attrnames'.
 
 paul@0   1217 
        """
 
 paul@0   1218 
 
 paul@0   1219 
        access = name, attrnames
 
 paul@0   1220 
        path = self.get_path_for_access()
 
 paul@0   1221 
 
 paul@0   1222 
        init_item(self.attr_accessor_branches, path, dict)
 
 paul@0   1223 
        attr_accessor_branches = self.attr_accessor_branches[path]
 
 paul@0   1224 
 
 paul@0   1225 
        init_item(attr_accessor_branches, access, list)
 
 paul@0   1226 
        attr_accessor_branches[access].append(branches)
 
 paul@0   1227 
 
 paul@117   1228 
    def record_access_details(self, name, attrnames, assignment, invocation):
 
 paul@0   1229 
 
 paul@0   1230 
        """
 
 paul@0   1231 
        For the given 'name' and 'attrnames', record an access indicating
 
 paul@553   1232 
        whether an 'assignment' or an 'invocation' is occurring.
 
 paul@0   1233 
 
 paul@0   1234 
        These details correspond to accesses otherwise recorded by the attribute
 
 paul@0   1235 
        accessor and attribute access dictionaries.
 
 paul@0   1236 
        """
 
 paul@0   1237 
 
 paul@0   1238 
        access = name, attrnames
 
 paul@0   1239 
        path = self.get_path_for_access()
 
 paul@0   1240 
 
 paul@0   1241 
        init_item(self.attr_access_modifiers, path, dict)
 
 paul@0   1242 
        init_item(self.attr_access_modifiers[path], access, list)
 
 paul@0   1243 
 
 paul@0   1244 
        access_number = len(self.attr_access_modifiers[path][access])
 
 paul@117   1245 
        self.attr_access_modifiers[path][access].append((assignment, invocation))
 
 paul@0   1246 
        return access_number
 
 paul@0   1247 
 
 paul@0   1248 
    def record_global_access_details(self, name, attrnames):
 
 paul@0   1249 
 
 paul@0   1250 
        """
 
 paul@0   1251 
        Record details of a global access via the given 'name' involving the
 
 paul@0   1252 
        indicated 'attrnames'.
 
 paul@0   1253 
        """
 
 paul@0   1254 
 
 paul@0   1255 
        path = self.get_namespace_path()
 
 paul@0   1256 
 
 paul@0   1257 
        init_item(self.global_attr_accesses, path, dict)
 
 paul@0   1258 
        init_item(self.global_attr_accesses[path], name, set)
 
 paul@0   1259 
        self.global_attr_accesses[path][name].add(attrnames)
 
 paul@0   1260 
 
 paul@0   1261 
    # Namespace modification.
 
 paul@0   1262 
 
 paul@0   1263 
    def record_name(self, name):
 
 paul@0   1264 
 
 paul@0   1265 
        "Record the use of 'name' in a namespace."
 
 paul@0   1266 
 
 paul@0   1267 
        path = self.get_namespace_path()
 
 paul@0   1268 
        init_item(self.names_used, path, set)
 
 paul@0   1269 
        self.names_used[path].add(name)
 
 paul@0   1270 
 
 paul@12   1271 
    def set_module(self, name, module_name):
 
 paul@0   1272 
 
 paul@0   1273 
        """
 
 paul@12   1274 
        Set a module in the current namespace using the given 'name' associated
 
 paul@12   1275 
        with the corresponding 'module_name'.
 
 paul@0   1276 
        """
 
 paul@0   1277 
 
 paul@0   1278 
        if name:
 
 paul@12   1279 
            self.set_general_local(name, Reference("<module>", module_name))
 
 paul@0   1280 
 
 paul@0   1281 
    def set_definition(self, name, kind):
 
 paul@0   1282 
 
 paul@0   1283 
        """
 
 paul@0   1284 
        Set the definition having the given 'name' and 'kind'.
 
 paul@0   1285 
 
 paul@0   1286 
        Definitions are set in the static namespace hierarchy, but they can also
 
 paul@0   1287 
        be recorded for function locals.
 
 paul@0   1288 
        """
 
 paul@0   1289 
 
 paul@0   1290 
        if self.is_global(name):
 
 paul@0   1291 
            print >>sys.stderr, "In %s, %s is defined as being global." % (
 
 paul@0   1292 
                self.get_namespace_path(), name)
 
 paul@0   1293 
 
 paul@0   1294 
        path = self.get_object_path(name)
 
 paul@0   1295 
        self.set_object(path, kind)
 
 paul@0   1296 
 
 paul@0   1297 
        ref = self.get_object(path)
 
 paul@0   1298 
        if ref.get_kind() == "<var>":
 
 paul@0   1299 
            print >>sys.stderr, "In %s, %s is defined more than once." % (
 
 paul@0   1300 
                self.get_namespace_path(), name)
 
 paul@0   1301 
 
 paul@0   1302 
        if not self.is_global(name) and self.in_function:
 
 paul@0   1303 
            self.set_function_local(name, ref)
 
 paul@0   1304 
 
 paul@0   1305 
    def set_function_local(self, name, ref=None):
 
 paul@0   1306 
 
 paul@0   1307 
        "Set the local with the given 'name' and optional 'ref'."
 
 paul@0   1308 
 
 paul@781   1309 
        path = self.get_namespace_path()
 
 paul@781   1310 
        locals = self.function_locals[path]
 
 paul@781   1311 
        used = self.names_used.get(path)
 
 paul@781   1312 
 
 paul@781   1313 
        if not locals.has_key(name) and used and name in used:
 
 paul@781   1314 
            raise InspectError("Name %s assigned locally but used previously." % name, path)
 
 paul@781   1315 
 
 paul@0   1316 
        multiple = not ref or locals.has_key(name) and locals[name] != ref
 
 paul@0   1317 
        locals[name] = multiple and Reference("<var>") or ref
 
 paul@0   1318 
 
 paul@0   1319 
    def assign_general_local(self, name, name_ref):
 
 paul@0   1320 
 
 paul@0   1321 
        """
 
 paul@0   1322 
        Set for 'name' the given 'name_ref', recording the name for attribute
 
 paul@0   1323 
        usage tracking.
 
 paul@0   1324 
        """
 
 paul@0   1325 
 
 paul@0   1326 
        self.set_general_local(name, name_ref)
 
 paul@0   1327 
        self.assign_name(name, name_ref)
 
 paul@0   1328 
 
 paul@0   1329 
    def set_general_local(self, name, value=None):
 
 paul@0   1330 
 
 paul@0   1331 
        """
 
 paul@0   1332 
        Set the 'name' with optional 'value' in any kind of local namespace,
 
 paul@0   1333 
        where the 'value' should be a reference if specified.
 
 paul@0   1334 
        """
 
 paul@0   1335 
 
 paul@0   1336 
        init_value = self.get_initialising_value(value)
 
 paul@0   1337 
 
 paul@0   1338 
        # Module global names.
 
 paul@0   1339 
 
 paul@0   1340 
        if self.is_global(name):
 
 paul@0   1341 
            path = self.get_global_path(name)
 
 paul@0   1342 
            self.set_object(path, init_value)
 
 paul@0   1343 
 
 paul@0   1344 
        # Function local names.
 
 paul@0   1345 
 
 paul@0   1346 
        elif self.in_function:
 
 paul@0   1347 
            self.set_function_local(name, init_value)
 
 paul@0   1348 
 
 paul@0   1349 
        # Other namespaces (classes).
 
 paul@0   1350 
 
 paul@0   1351 
        else:
 
 paul@0   1352 
            self.set_name(name, init_value)
 
 paul@0   1353 
 
 paul@0   1354 
    def set_name(self, name, ref=None):
 
 paul@0   1355 
 
 paul@0   1356 
        "Attach the 'name' with optional 'ref' to the current namespace."
 
 paul@0   1357 
 
 paul@0   1358 
        self.set_object(self.get_object_path(name), ref)
 
 paul@0   1359 
 
 paul@0   1360 
    def set_instance_attr(self, name, ref=None):
 
 paul@0   1361 
 
 paul@0   1362 
        """
 
 paul@0   1363 
        Add an instance attribute of the given 'name' to the current class,
 
 paul@0   1364 
        using the optional 'ref'.
 
 paul@0   1365 
        """
 
 paul@0   1366 
 
 paul@251   1367 
        self._set_instance_attr(self.in_class, name, ref)
 
 paul@251   1368 
 
 paul@251   1369 
    def _set_instance_attr(self, path, name, ref=None):
 
 paul@251   1370 
 
 paul@251   1371 
        init_item(self.instance_attrs, path, set)
 
 paul@251   1372 
        self.instance_attrs[path].add(name)
 
 paul@0   1373 
 
 paul@0   1374 
        if ref:
 
 paul@251   1375 
            init_item(self.instance_attr_constants, path, dict)
 
 paul@251   1376 
            self.instance_attr_constants[path][name] = ref
 
 paul@0   1377 
 
 paul@0   1378 
    def get_initialising_value(self, value):
 
 paul@0   1379 
 
 paul@0   1380 
        "Return a suitable initialiser reference for 'value'."
 
 paul@0   1381 
 
 paul@794   1382 
        if isinstance(value, Result):
 
 paul@0   1383 
            return value.reference()
 
 paul@0   1384 
        else:
 
 paul@0   1385 
            return value
 
 paul@0   1386 
 
 paul@0   1387 
    # Static, program-relative naming.
 
 paul@0   1388 
 
 paul@0   1389 
    def find_name(self, name):
 
 paul@0   1390 
 
 paul@0   1391 
        """
 
 paul@0   1392 
        Return the qualified name for the given 'name' used in the current
 
 paul@0   1393 
        non-function namespace.
 
 paul@0   1394 
        """
 
 paul@0   1395 
 
 paul@0   1396 
        path = self.get_namespace_path()
 
 paul@0   1397 
        ref = None
 
 paul@0   1398 
 
 paul@0   1399 
        if not self.in_function and name not in predefined_constants:
 
 paul@0   1400 
            if self.in_class:
 
 paul@152   1401 
                ref = self.get_object(self.get_object_path(name), False)
 
 paul@0   1402 
            if not ref:
 
 paul@0   1403 
                ref = self.get_global_or_builtin(name)
 
 paul@0   1404 
 
 paul@0   1405 
        return ref
 
 paul@0   1406 
 
 paul@0   1407 
    def get_class(self, node):
 
 paul@0   1408 
 
 paul@0   1409 
        """
 
 paul@0   1410 
        Use the given 'node' to obtain the identity of a class. Return a
 
 paul@0   1411 
        reference for the class. Unresolved dependencies are permitted and must
 
 paul@0   1412 
        be resolved later.
 
 paul@0   1413 
        """
 
 paul@0   1414 
 
 paul@0   1415 
        ref = self._get_class(node)
 
 paul@0   1416 
        return ref.has_kind(["<class>", "<depends>"]) and ref or None
 
 paul@0   1417 
 
 paul@0   1418 
    def _get_class(self, node):
 
 paul@0   1419 
 
 paul@0   1420 
        """
 
 paul@0   1421 
        Use the given 'node' to find a class definition. Return a reference to
 
 paul@0   1422 
        the class.
 
 paul@0   1423 
        """
 
 paul@0   1424 
 
 paul@0   1425 
        if isinstance(node, compiler.ast.Getattr):
 
 paul@0   1426 
 
 paul@0   1427 
            # Obtain the identity of the access target.
 
 paul@0   1428 
 
 paul@0   1429 
            ref = self._get_class(node.expr)
 
 paul@0   1430 
 
 paul@0   1431 
            # Where the target is a class or module, obtain the identity of the
 
 paul@0   1432 
            # attribute.
 
 paul@0   1433 
 
 paul@0   1434 
            if ref.has_kind(["<function>", "<var>"]):
 
 paul@0   1435 
                return None
 
 paul@0   1436 
            else:
 
 paul@0   1437 
                attrname = "%s.%s" % (ref.get_origin(), node.attrname)
 
 paul@0   1438 
                return self.get_object(attrname)
 
 paul@0   1439 
 
 paul@0   1440 
        # Names can be module-level or built-in.
 
 paul@0   1441 
 
 paul@0   1442 
        elif isinstance(node, compiler.ast.Name):
 
 paul@0   1443 
 
 paul@0   1444 
            # Record usage of the name and attempt to identify it.
 
 paul@0   1445 
 
 paul@0   1446 
            self.record_name(node.name)
 
 paul@73   1447 
            return self.find_name(node.name)
 
 paul@0   1448 
        else:
 
 paul@0   1449 
            return None
 
 paul@0   1450 
 
 paul@0   1451 
    def get_constant(self, name, value):
 
 paul@0   1452 
 
 paul@0   1453 
        "Return a constant reference for the given type 'name' and 'value'."
 
 paul@0   1454 
 
 paul@12   1455 
        ref = self.get_builtin_class(name)
 
 paul@0   1456 
        return self.get_constant_reference(ref, value)
 
 paul@0   1457 
 
 paul@405   1458 
    def get_literal_instance(self, n, name=None):
 
 paul@0   1459 
 
 paul@405   1460 
        """
 
 paul@405   1461 
        For node 'n', return a reference to an instance of 'name', or if 'name'
 
 paul@405   1462 
        is not specified, deduce the type from the value.
 
 paul@405   1463 
        """
 
 paul@0   1464 
 
 paul@366   1465 
        # Handle stray None constants (Sliceobj seems to produce them).
 
 paul@366   1466 
 
 paul@366   1467 
        if name == "NoneType":
 
 paul@366   1468 
            return self.process_name_node(compiler.ast.Name("None"))
 
 paul@366   1469 
 
 paul@0   1470 
        # Obtain the details of the literal itself.
 
 paul@0   1471 
        # An alias to the type is generated for sequences.
 
 paul@0   1472 
 
 paul@0   1473 
        if name in ("dict", "list", "tuple"):
 
 paul@405   1474 
            ref = self.get_builtin_class(name)
 
 paul@0   1475 
            self.set_special_literal(name, ref)
 
 paul@0   1476 
            return self.process_literal_sequence_node(n, name, ref, LiteralSequenceRef)
 
 paul@0   1477 
 
 paul@0   1478 
        # Constant values are independently recorded.
 
 paul@0   1479 
 
 paul@0   1480 
        else:
 
 paul@537   1481 
            value, typename, encoding = self.get_constant_value(n.value, n.literals)
 
 paul@538   1482 
            ref = self.get_builtin_class(typename)
 
 paul@406   1483 
            return self.get_constant_reference(ref, value, encoding)
 
 paul@0   1484 
 
 paul@17   1485 
    # Special names.
 
 paul@0   1486 
 
 paul@17   1487 
    def get_special(self, name):
 
 paul@0   1488 
 
 paul@17   1489 
        "Return any stored value for the given special 'name'."
 
 paul@0   1490 
 
 paul@423   1491 
        value = self.special.get(name)
 
 paul@423   1492 
        if value:
 
 paul@423   1493 
            ref, paths = value
 
 paul@423   1494 
        else:
 
 paul@423   1495 
            ref = None
 
 paul@423   1496 
        return ref
 
 paul@17   1497 
 
 paul@17   1498 
    def set_special(self, name, value):
 
 paul@0   1499 
 
 paul@17   1500 
        """
 
 paul@17   1501 
        Set a special 'name' that merely tracks the use of an implicit object
 
 paul@17   1502 
        'value'.
 
 paul@17   1503 
        """
 
 paul@0   1504 
 
 paul@423   1505 
        if not self.special.has_key(name):
 
 paul@423   1506 
            paths = set()
 
 paul@423   1507 
            self.special[name] = value, paths
 
 paul@423   1508 
        else:
 
 paul@423   1509 
            _ref, paths = self.special[name]
 
 paul@423   1510 
 
 paul@423   1511 
        paths.add(self.get_namespace_path())
 
 paul@17   1512 
 
 paul@17   1513 
    def set_special_literal(self, name, ref):
 
 paul@0   1514 
 
 paul@17   1515 
        """
 
 paul@17   1516 
        Set a special name for the literal type 'name' having type 'ref'. Such
 
 paul@17   1517 
        special names provide a way of referring to literal object types.
 
 paul@17   1518 
        """
 
 paul@0   1519 
 
 paul@17   1520 
        literal_name = "$L%s" % name
 
 paul@17   1521 
        value = ResolvedNameRef(literal_name, ref)
 
 paul@17   1522 
        self.set_special(literal_name, value)
 
 paul@0   1523 
 
 paul@479   1524 
    # Exceptions.
 
 paul@479   1525 
 
 paul@479   1526 
    def record_exception_handler(self):
 
 paul@479   1527 
 
 paul@479   1528 
        "Record the current namespace as employing an exception handler."
 
 paul@479   1529 
 
 paul@479   1530 
        self.exception_namespaces.add(self.get_namespace_path())
 
 paul@479   1531 
 
 paul@703   1532 
    # Return values.
 
 paul@703   1533 
 
 paul@703   1534 
    def record_return_value(self, expr):
 
 paul@703   1535 
 
 paul@703   1536 
        "Record the given return 'expr'."
 
 paul@703   1537 
 
 paul@703   1538 
        path = self.get_namespace_path()
 
 paul@742   1539 
        l = init_item(self.return_values, path, list)
 
 paul@742   1540 
        l.append(expr)
 
 paul@742   1541 
        if not self.importer.all_return_values.has_key(path):
 
 paul@742   1542 
            self.importer.all_return_values[path] = l
 
 paul@703   1543 
 
 paul@0   1544 
# vim: tabstop=4 expandtab shiftwidth=4