Lichen

Annotated resolving.py

288:fff09c70f489
2016-11-30 Paul Boddie Implemented the dictionary items method and expanded IndexError. Expanded the dictionary test program.
paul@12 1
#!/usr/bin/env python
paul@12 2
paul@12 3
"""
paul@12 4
Name resolution.
paul@12 5
paul@12 6
Copyright (C) 2016 Paul Boddie <paul@boddie.org.uk>
paul@12 7
paul@12 8
This program is free software; you can redistribute it and/or modify it under
paul@12 9
the terms of the GNU General Public License as published by the Free Software
paul@12 10
Foundation; either version 3 of the License, or (at your option) any later
paul@12 11
version.
paul@12 12
paul@12 13
This program is distributed in the hope that it will be useful, but WITHOUT
paul@12 14
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
paul@12 15
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
paul@12 16
details.
paul@12 17
paul@12 18
You should have received a copy of the GNU General Public License along with
paul@12 19
this program.  If not, see <http://www.gnu.org/licenses/>.
paul@12 20
"""
paul@12 21
paul@135 22
from common import init_item
paul@12 23
from results import AccessRef, InstanceRef, InvocationRef, LocalNameRef, \
paul@12 24
                    NameRef, ResolvedNameRef
paul@12 25
from referencing import Reference
paul@12 26
import sys
paul@12 27
paul@12 28
class NameResolving:
paul@12 29
paul@12 30
    "Resolving names mix-in for inspected modules."
paul@12 31
paul@12 32
    # Post-inspection resolution activities.
paul@12 33
paul@12 34
    def resolve(self):
paul@12 35
paul@12 36
        "Resolve dependencies and complete definitions."
paul@12 37
paul@12 38
        self.resolve_class_bases()
paul@21 39
        self.check_special()
paul@12 40
        self.check_names_used()
paul@27 41
        self.check_invocations()
paul@12 42
        self.resolve_initialisers()
paul@12 43
        self.resolve_literals()
paul@12 44
paul@12 45
    def resolve_class_bases(self):
paul@12 46
paul@12 47
        "Resolve all class bases since some of them may have been deferred."
paul@12 48
paul@12 49
        for name, bases in self.classes.items():
paul@12 50
            resolved = []
paul@12 51
            bad = []
paul@12 52
paul@12 53
            for base in bases:
paul@27 54
                ref = self.importer.identify(base.get_origin())
paul@12 55
paul@12 56
                # Obtain the origin of the base class reference.
paul@12 57
paul@12 58
                if not ref or not ref.has_kind("<class>"):
paul@12 59
                    bad.append(base)
paul@12 60
                    break
paul@12 61
paul@12 62
                resolved.append(ref)
paul@12 63
paul@12 64
            if bad:
paul@72 65
                print >>sys.stderr, "Bases of class %s were not classes: %s" % (name, ", ".join(map(str, bad)))
paul@12 66
            else:
paul@12 67
                self.importer.classes[name] = self.classes[name] = resolved
paul@12 68
paul@12 69
    def check_special(self):
paul@12 70
paul@12 71
        "Check special names."
paul@12 72
paul@12 73
        for name, value in self.special.items():
paul@28 74
            self.special[name] = self.importer.identify(value.get_origin())
paul@12 75
paul@12 76
    def check_names_used(self):
paul@12 77
paul@27 78
        "Check the external names used by each scope."
paul@12 79
paul@27 80
        for key, ref in self.name_references.items():
paul@27 81
            path, name = key.rsplit(".", 1)
paul@27 82
            self.resolve_accesses(path, name, ref)
paul@12 83
paul@27 84
    def check_invocations(self):
paul@12 85
paul@27 86
        "Find invocations amongst module data and replace their results."
paul@12 87
paul@27 88
        # Find members and replace invocation results with values. This is
paul@27 89
        # effectively the same as is done for initialised names, but refers to
paul@27 90
        # any unchanging value after initialisation.
paul@12 91
paul@27 92
        for key, ref in self.objects.items():
paul@27 93
            if ref.has_kind("<invoke>"):
paul@27 94
                ref = self.convert_invocation(ref)
paul@27 95
                self.importer.objects[key] = self.objects[key] = ref
paul@12 96
paul@169 97
        # Convert name references.
paul@169 98
paul@169 99
        for key, ref in self.name_references.items():
paul@169 100
            if ref.has_kind("<invoke>"):
paul@169 101
                ref = self.convert_invocation(ref)
paul@169 102
                self.importer.all_name_references[key] = self.name_references[key] = ref
paul@169 103
paul@31 104
        # Convert function defaults, which are effectively extra members of the
paul@31 105
        # module, and function locals.
paul@12 106
paul@31 107
        for fname, parameters in self.function_defaults.items():
paul@27 108
            l = []
paul@27 109
            for pname, ref in parameters:
paul@27 110
                if ref.has_kind("<invoke>"):
paul@27 111
                    ref = self.convert_invocation(ref)
paul@27 112
                l.append((pname, ref))
paul@129 113
            self.importer.function_defaults[fname] = self.function_defaults[fname] = l
paul@12 114
paul@31 115
        # Convert function locals referencing invocations.
paul@31 116
paul@31 117
        for fname, names in self.function_locals.items():
paul@31 118
            for name, ref in names.items():
paul@31 119
                if ref.has_kind("<invoke>"):
paul@31 120
                    ref = self.convert_invocation(ref)
paul@31 121
                    names[name] = ref
paul@31 122
paul@27 123
    def convert_invocation(self, ref):
paul@27 124
paul@27 125
        "Convert the given invocation 'ref', handling instantiation."
paul@27 126
paul@175 127
        alias = ref.get_name()
paul@27 128
        ref = self.importer.identify(ref.get_origin())
paul@175 129
        ref = ref and ref.has_kind("<class>") and ref.instance_of() or Reference("<var>")
paul@175 130
        return ref and ref.alias(alias) or None
paul@12 131
paul@12 132
    def resolve_accesses(self, path, name, ref):
paul@12 133
paul@12 134
        """
paul@12 135
        Resolve any unresolved accesses in the function at the given 'path'
paul@12 136
        for the given 'name' corresponding to the indicated 'ref'. Note that
paul@12 137
        this mechanism cannot resolve things like inherited methods because
paul@12 138
        they are not recorded as program objects in their inherited locations.
paul@12 139
        """
paul@12 140
paul@12 141
        attr_accesses = self.global_attr_accesses.get(path)
paul@12 142
        all_attrnames = attr_accesses and attr_accesses.get(name)
paul@12 143
paul@12 144
        if not all_attrnames:
paul@12 145
            return
paul@12 146
paul@12 147
        # Insist on constant accessors.
paul@12 148
paul@12 149
        if not ref.has_kind(["<class>", "<module>"]):
paul@12 150
            return
paul@12 151
paul@12 152
        found_attrnames = set()
paul@12 153
paul@12 154
        for attrnames in all_attrnames:
paul@12 155
paul@12 156
            # Start with the resolved name, adding attributes.
paul@12 157
paul@12 158
            attrs = ref.get_path()
paul@12 159
            remaining = attrnames.split(".")
paul@12 160
            last_ref = ref
paul@12 161
paul@12 162
            # Add each component, testing for a constant object.
paul@12 163
paul@12 164
            while remaining:
paul@12 165
                attrname = remaining[0]
paul@12 166
                attrs.append(attrname)
paul@12 167
                del remaining[0]
paul@12 168
paul@12 169
                # Find any constant object reference.
paul@12 170
paul@12 171
                attr_ref = self.get_resolved_object(".".join(attrs))
paul@12 172
paul@12 173
                # Non-constant accessors terminate the traversal.
paul@12 174
paul@12 175
                if not attr_ref or not attr_ref.has_kind(["<class>", "<module>", "<function>"]):
paul@12 176
paul@12 177
                    # Provide the furthest constant accessor unless the final
paul@12 178
                    # access can be resolved.
paul@12 179
paul@12 180
                    if remaining:
paul@12 181
                        remaining.insert(0, attrs.pop())
paul@12 182
                    else:
paul@12 183
                        last_ref = attr_ref
paul@12 184
                    break
paul@12 185
paul@12 186
                # Follow any reference to a constant object.
paul@12 187
                # Where the given name refers to an object in another location,
paul@12 188
                # switch to the other location in order to be able to test its
paul@12 189
                # attributes.
paul@12 190
paul@12 191
                last_ref = attr_ref
paul@12 192
                attrs = attr_ref.get_path()
paul@12 193
paul@12 194
            # Record a constant accessor only if an object was found
paul@12 195
            # that is different from the namespace involved.
paul@12 196
paul@12 197
            if last_ref:
paul@12 198
                objpath = ".".join(attrs)
paul@12 199
                if objpath != path:
paul@12 200
paul@27 201
                    if last_ref.has_kind("<invoke>"):
paul@27 202
                        last_ref = self.convert_invocation(last_ref)
paul@27 203
paul@12 204
                    # Establish a constant access.
paul@12 205
paul@12 206
                    init_item(self.const_accesses, path, dict)
paul@12 207
                    self.const_accesses[path][(name, attrnames)] = (objpath, last_ref, ".".join(remaining))
paul@12 208
paul@12 209
                    if len(attrs) > 1:
paul@12 210
                        found_attrnames.add(attrs[1])
paul@12 211
paul@12 212
        # Remove any usage records for the name.
paul@12 213
paul@12 214
        if found_attrnames:
paul@12 215
paul@12 216
            # NOTE: Should be only one name version.
paul@12 217
paul@12 218
            versions = []
paul@12 219
            for version in self.attr_usage[path][name]:
paul@12 220
                new_usage = set()
paul@12 221
                for usage in version:
paul@12 222
                    if found_attrnames.intersection(usage):
paul@12 223
                        new_usage.add(tuple(set(usage).difference(found_attrnames)))
paul@12 224
                    else:
paul@12 225
                        new_usage.add(usage)
paul@12 226
                versions.append(new_usage)
paul@12 227
paul@12 228
            self.attr_usage[path][name] = versions
paul@12 229
paul@12 230
    def resolve_initialisers(self):
paul@12 231
paul@12 232
        "Resolve initialiser values for names."
paul@12 233
paul@12 234
        # Get the initialisers in each namespace.
paul@12 235
paul@12 236
        for path, name_initialisers in self.name_initialisers.items():
paul@12 237
            const_accesses = self.const_accesses.get(path)
paul@12 238
paul@12 239
            # Resolve values for each name in a scope.
paul@12 240
paul@12 241
            for name, values in name_initialisers.items():
paul@12 242
                if path == self.name:
paul@12 243
                    assigned_path = name
paul@12 244
                else:
paul@12 245
                    assigned_path = "%s.%s" % (path, name)
paul@12 246
paul@12 247
                initialised_names = {}
paul@12 248
                aliased_names = {}
paul@12 249
paul@12 250
                for i, name_ref in enumerate(values):
paul@12 251
paul@12 252
                    # Unwrap invocations.
paul@12 253
paul@12 254
                    if isinstance(name_ref, InvocationRef):
paul@12 255
                        invocation = True
paul@12 256
                        name_ref = name_ref.name_ref
paul@12 257
                    else:
paul@12 258
                        invocation = False
paul@12 259
paul@12 260
                    # Obtain a usable reference from names or constants.
paul@12 261
paul@12 262
                    if isinstance(name_ref, ResolvedNameRef):
paul@12 263
                        if not name_ref.reference():
paul@12 264
                            continue
paul@12 265
                        ref = name_ref.reference()
paul@12 266
paul@12 267
                    # Obtain a reference from instances.
paul@12 268
paul@12 269
                    elif isinstance(name_ref, InstanceRef):
paul@12 270
                        if not name_ref.reference():
paul@12 271
                            continue
paul@12 272
                        ref = name_ref.reference()
paul@12 273
paul@12 274
                    # Resolve accesses that employ constants.
paul@12 275
paul@12 276
                    elif isinstance(name_ref, AccessRef):
paul@12 277
                        ref = None
paul@12 278
paul@12 279
                        if const_accesses:
paul@12 280
                            resolved_access = const_accesses.get((name_ref.original_name, name_ref.attrnames))
paul@12 281
                            if resolved_access:
paul@12 282
                                objpath, ref, remaining_attrnames = resolved_access
paul@12 283
                                if remaining_attrnames:
paul@12 284
                                    ref = None
paul@12 285
paul@12 286
                        # Accesses that do not employ constants cannot be resolved,
paul@12 287
                        # but they may be resolvable later.
paul@12 288
paul@12 289
                        if not ref:
paul@12 290
                            if not invocation:
paul@12 291
                                aliased_names[i] = name_ref.original_name, name_ref.attrnames, name_ref.number
paul@12 292
                            continue
paul@12 293
paul@12 294
                    # Attempt to resolve a plain name reference.
paul@12 295
paul@12 296
                    elif isinstance(name_ref, LocalNameRef):
paul@12 297
                        key = "%s.%s" % (path, name_ref.name)
paul@12 298
                        origin = self.name_references.get(key)
paul@12 299
paul@12 300
                        # Accesses that do not refer to known static objects
paul@12 301
                        # cannot be resolved, but they may be resolvable later.
paul@12 302
paul@12 303
                        if not origin:
paul@12 304
                            if not invocation:
paul@12 305
                                aliased_names[i] = name_ref.name, None, name_ref.number
paul@12 306
                            continue
paul@12 307
paul@12 308
                        ref = self.get_resolved_object(origin)
paul@12 309
                        if not ref:
paul@12 310
                            continue
paul@12 311
paul@12 312
                    elif isinstance(name_ref, NameRef):
paul@12 313
                        key = "%s.%s" % (path, name_ref.name)
paul@12 314
                        origin = self.name_references.get(key)
paul@12 315
                        if not origin:
paul@12 316
                            continue
paul@12 317
paul@12 318
                        ref = self.get_resolved_object(origin)
paul@12 319
                        if not ref:
paul@12 320
                            continue
paul@12 321
paul@12 322
                    else:
paul@12 323
                        continue
paul@12 324
paul@22 325
                    # Resolve any hidden dependencies involving external objects
paul@22 326
                    # or unresolved names referring to globals or built-ins.
paul@22 327
paul@22 328
                    if ref.has_kind("<depends>"):
paul@27 329
                        ref = self.importer.identify(ref.get_origin())
paul@22 330
paul@12 331
                    # Convert class invocations to instances.
paul@12 332
paul@58 333
                    if ref and invocation:
paul@27 334
                        ref = self.convert_invocation(ref)
paul@12 335
paul@27 336
                    if ref and not ref.has_kind("<var>"):
paul@12 337
                        initialised_names[i] = ref
paul@12 338
paul@12 339
                if initialised_names:
paul@12 340
                    self.initialised_names[assigned_path] = initialised_names
paul@12 341
                if aliased_names:
paul@12 342
                    self.aliased_names[assigned_path] = aliased_names
paul@12 343
paul@12 344
    def resolve_literals(self):
paul@12 345
paul@12 346
        "Resolve constant value types."
paul@12 347
paul@12 348
        # Get the constants defined in each namespace.
paul@12 349
paul@12 350
        for path, constants in self.constants.items():
paul@12 351
            for constant, n in constants.items():
paul@12 352
                objpath = "%s.$c%d" % (path, n)
paul@12 353
                _constant, value_type = self.constant_values[objpath]
paul@12 354
                self.initialised_names[objpath] = {0 : Reference("<instance>", value_type)}
paul@12 355
paul@12 356
        # Get the literals defined in each namespace.
paul@12 357
paul@12 358
        for path, literals in self.literals.items():
paul@12 359
            for n in range(0, literals):
paul@12 360
                objpath = "%s.$C%d" % (path, n)
paul@12 361
                value_type = self.literal_types[objpath]
paul@12 362
                self.initialised_names[objpath] = {0 : Reference("<instance>", value_type)}
paul@12 363
paul@29 364
    # Object resolution.
paul@29 365
paul@29 366
    def get_resolved_object(self, path):
paul@29 367
paul@29 368
        """
paul@29 369
        Get the details of an object with the given 'path' within this module.
paul@29 370
        Where the object has not been resolved, None is returned. This differs
paul@29 371
        from the get_object method used elsewhere in that it does not return an
paul@29 372
        unresolved object reference.
paul@29 373
        """
paul@29 374
paul@29 375
        if self.objects.has_key(path):
paul@29 376
            ref = self.objects[path]
paul@29 377
            if ref.has_kind("<depends>"):
paul@29 378
                return None
paul@29 379
            else:
paul@29 380
                return ref
paul@29 381
        else:
paul@29 382
            return None
paul@29 383
paul@12 384
# vim: tabstop=4 expandtab shiftwidth=4