Lichen

Annotated inspector.py

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