Lichen

Annotated inspector.py

938:799711337453
6 months ago Paul Boddie Renamed the string class to str, replacing the str function with the new_str function, this being invoked specially by the string instantiation function. As with the Unicode type renaming, a more general instantiation mechanism might permit the new_str function to be part of the functionality of the str or basestring classes.
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